diff --git a/ui/goose2/src/features/chat/hooks/ArtifactPolicyContext.tsx b/ui/goose2/src/features/chat/hooks/ArtifactPolicyContext.tsx
index 0774a6d3b853..e2f045609aff 100644
--- a/ui/goose2/src/features/chat/hooks/ArtifactPolicyContext.tsx
+++ b/ui/goose2/src/features/chat/hooks/ArtifactPolicyContext.tsx
@@ -65,6 +65,45 @@ const ArtifactPolicyContext = createContext<ArtifactPolicyContextValue>(
   DEFAULT_CONTEXT_VALUE,
 );
 
+function isArtifactActionTool(toolName: string): boolean {
+  const normalized = toolName.trim().toLowerCase();
+  if (/^(write|writing|create|creating|save|saving)\b/.test(normalized)) {
+    return true;
+  }
+
+  return (
+    normalized.includes("write_file") ||
+    normalized.includes("create_file") ||
+    normalized.includes("save_file")
+  );
+}
+
+function buildToolCardDisplay(
+  candidates: ArtifactPathCandidate[],
+): ToolCardDisplay {
+  if (candidates.length === 0) {
+    return EMPTY_DISPLAY;
+  }
+
+  const firstAllowedIndex = candidates.findIndex(
+    (candidate) => candidate.allowed,
+  );
+  const primaryIndex = firstAllowedIndex === -1 ? 0 : firstAllowedIndex;
+  const primaryCandidate = candidates[primaryIndex] ?? null;
+
+  if (!primaryCandidate) {
+    return EMPTY_DISPLAY;
+  }
+
+  return {
+    role: "primary_host",
+    primaryCandidate,
+    secondaryCandidates: candidates.filter(
+      (_candidate, index) => index !== primaryIndex,
+    ),
+  };
+}
+
 function shortenPath(fullPath: string, homeDir: string | null): string {
   if (homeDir && fullPath.startsWith(homeDir)) {
     return `~${fullPath.slice(homeDir.length)}`;
@@ -150,18 +189,17 @@ export function ArtifactPolicyProvider({
     const displayByToolCallId = new Map<string, ToolCardDisplay>();
 
     for (const ranking of artifactsIndex.byMessageId.values()) {
-      if (!ranking.primaryToolCallId || !ranking.primaryCandidate) continue;
-      if (
-        !ranking.primaryCandidate.toolName ||
-        !isWriteOrientedTool(ranking.primaryCandidate.toolName)
-      ) {
-        continue;
+      for (const [toolCallId, candidates] of ranking.candidatesByToolCallId) {
+        const toolName = candidates[0]?.toolName;
+        if (!toolName || !isArtifactActionTool(toolName)) {
+          continue;
+        }
+
+        const display = buildToolCardDisplay(candidates);
+        if (display.role === "primary_host") {
+          displayByToolCallId.set(toolCallId, display);
+        }
       }
-      displayByToolCallId.set(ranking.primaryToolCallId, {
-        role: "primary_host",
-        primaryCandidate: ranking.primaryCandidate,
-        secondaryCandidates: ranking.secondaryCandidates,
-      });
     }
 
     return {
diff --git a/ui/goose2/src/features/chat/hooks/__tests__/ArtifactPolicyContext.test.tsx b/ui/goose2/src/features/chat/hooks/__tests__/ArtifactPolicyContext.test.tsx
deleted file mode 100644
index 0ea636e86ab9..000000000000
--- a/ui/goose2/src/features/chat/hooks/__tests__/ArtifactPolicyContext.test.tsx
+++ /dev/null
@@ -1,424 +0,0 @@
-import { render, screen, waitFor } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
-import type { Message } from "@/shared/types/messages";
-import {
-  ArtifactPolicyProvider,
-  useArtifactPolicyContext,
-} from "../ArtifactPolicyContext";
-
-import { openPath } from "@tauri-apps/plugin-opener";
-
-const mockPathExists = vi.fn<(path: string) => Promise<boolean>>();
-
-vi.mock("@/shared/api/system", () => ({
-  pathExists: (path: string) => mockPathExists(path),
-}));
-
-function Probe({
-  readArgs,
-  writeArgs,
-  clonedWriteArgs,
-}: {
-  readArgs: Record<string, unknown>;
-  writeArgs: Record<string, unknown>;
-  clonedWriteArgs: Record<string, unknown>;
-}) {
-  const { resolveToolCardDisplay } = useArtifactPolicyContext();
-  const readDisplay = resolveToolCardDisplay(readArgs, "read_file");
-  const writeDisplay = resolveToolCardDisplay(writeArgs, "write_file");
-  const clonedDisplay = resolveToolCardDisplay(clonedWriteArgs, "write_file");
-
-  return (
-    <div>
-      <span data-testid="read-role">{readDisplay.role}</span>
-      <span data-testid="write-role">{writeDisplay.role}</span>
-      <span data-testid="write-primary">
-        {writeDisplay.primaryCandidate?.resolvedPath ?? ""}
-      </span>
-      <span data-testid="write-secondary-count">
-        {String(writeDisplay.secondaryCandidates.length)}
-      </span>
-      <span data-testid="cloned-role">{clonedDisplay.role}</span>
-    </div>
-  );
-}
-
-function TextFollowupProbe({
-  writeArgs,
-}: {
-  writeArgs: Record<string, unknown>;
-}) {
-  const { resolveToolCardDisplay, getAllSessionArtifacts } =
-    useArtifactPolicyContext();
-  const display = resolveToolCardDisplay(
-    writeArgs,
-    "writing markdown file about alphabet history",
-  );
-  const artifacts = getAllSessionArtifacts();
-
-  return (
-    <div>
-      <span data-testid="text-followup-role">{display.role}</span>
-      <span data-testid="text-followup-path">
-        {display.primaryCandidate?.resolvedPath ?? ""}
-      </span>
-      <span data-testid="text-followup-artifacts">
-        {artifacts.map((artifact) => artifact.resolvedPath).join(",")}
-      </span>
-    </div>
-  );
-}
-
-function ReadOnlyProbe({ readArgs }: { readArgs: Record<string, unknown> }) {
-  const { resolveToolCardDisplay, getAllSessionArtifacts } =
-    useArtifactPolicyContext();
-  const display = resolveToolCardDisplay(readArgs, "read_file");
-  const artifacts = getAllSessionArtifacts();
-
-  return (
-    <div>
-      <span data-testid="read-only-role">{display.role}</span>
-      <span data-testid="read-only-artifacts">
-        {artifacts.map((artifact) => artifact.resolvedPath).join(",")}
-      </span>
-    </div>
-  );
-}
-
-function FallbackProbe({
-  path = "/Users/test/.goose/projects/sample-project/artifacts/report.md",
-}: {
-  path?: string;
-}) {
-  const { pathExists, openResolvedPath } = useArtifactPolicyContext();
-
-  return (
-    <div>
-      <button
-        type="button"
-        onClick={async () => {
-          const exists = await pathExists(path);
-          (window as Window & { __artifactExists?: boolean }).__artifactExists =
-            exists;
-        }}
-      >
-        Check path
-      </button>
-      <button type="button" onClick={() => void openResolvedPath(path)}>
-        Open path
-      </button>
-    </div>
-  );
-}
-
-describe("ArtifactPolicyContext", () => {
-  it("computes one primary host per message and resolves tool cards by args identity", () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    const readArgs = { path: "/Users/test/project-a/notes.md" };
-    const writeArgs = {
-      paths: [
-        "/Users/test/project-a/output/final_report.md",
-        "/Users/test/project-a/output/notes.md",
-      ],
-    };
-    const messages: Message[] = [
-      {
-        id: "assistant-1",
-        role: "assistant",
-        created: Date.now(),
-        content: [
-          {
-            type: "toolRequest",
-            id: "tool-1",
-            name: "read_file",
-            arguments: readArgs,
-            status: "completed",
-          },
-          {
-            type: "toolResponse",
-            id: "tool-1",
-            name: "read_file",
-            result: "Read /Users/test/project-a/notes.md",
-            isError: false,
-          },
-          {
-            type: "toolRequest",
-            id: "tool-2",
-            name: "write_file",
-            arguments: writeArgs,
-            status: "completed",
-          },
-          {
-            type: "toolResponse",
-            id: "tool-2",
-            name: "write_file",
-            result: "Created /Users/test/project-a/output/final_report.md",
-            isError: false,
-          },
-        ],
-      },
-    ];
-
-    render(
-      <ArtifactPolicyProvider
-        messages={messages}
-        allowedRoots={["/Users/test/project-a", "/Users/test/.goose/artifacts"]}
-      >
-        <Probe
-          readArgs={readArgs}
-          writeArgs={writeArgs}
-          clonedWriteArgs={{ ...writeArgs }}
-        />
-      </ArtifactPolicyProvider>,
-    );
-
-    expect(screen.getByTestId("read-role")).toHaveTextContent("none");
-    expect(screen.getByTestId("write-role")).toHaveTextContent("primary_host");
-    expect(screen.getByTestId("write-primary")).toHaveTextContent(
-      "/Users/test/project-a/output/final_report.md",
-    );
-    expect(
-      Number(screen.getByTestId("write-secondary-count").textContent),
-    ).toBeGreaterThan(0);
-    expect(screen.getByTestId("cloned-role")).toHaveTextContent("none");
-  });
-
-  it("does not treat read-only tool paths as session artifacts", () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    const readArgs = { path: "/Users/test/project-a/notes.md" };
-    const messages: Message[] = [
-      {
-        id: "assistant-read-only",
-        role: "assistant",
-        created: Date.now(),
-        content: [
-          {
-            type: "toolRequest",
-            id: "tool-read",
-            name: "read_file",
-            arguments: readArgs,
-            status: "completed",
-          },
-          {
-            type: "toolResponse",
-            id: "tool-read",
-            name: "read_file",
-            result: "Read /Users/test/project-a/notes.md",
-            isError: false,
-          },
-        ],
-      },
-    ];
-
-    render(
-      <ArtifactPolicyProvider
-        messages={messages}
-        allowedRoots={["/Users/test/project-a", "/Users/test/.goose/artifacts"]}
-      >
-        <ReadOnlyProbe readArgs={readArgs} />
-      </ArtifactPolicyProvider>,
-    );
-
-    expect(screen.getByTestId("read-only-role")).toHaveTextContent("none");
-    expect(screen.getByTestId("read-only-artifacts")).toHaveTextContent("");
-  });
-
-  it("falls back to the home artifacts root when a project artifacts path is missing", async () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    mockPathExists.mockImplementation(
-      async (path: string) => path === "/Users/test/.goose/artifacts/report.md",
-    );
-
-    render(
-      <ArtifactPolicyProvider
-        messages={[]}
-        allowedRoots={[
-          "/Users/test/.goose/projects/sample-project/artifacts",
-          "/Users/test/.goose/artifacts",
-        ]}
-      >
-        <FallbackProbe />
-      </ArtifactPolicyProvider>,
-    );
-
-    screen.getByRole("button", { name: "Check path" }).click();
-    await waitFor(() => {
-      expect(
-        (window as Window & { __artifactExists?: boolean }).__artifactExists,
-      ).toBe(true);
-    });
-
-    screen.getByRole("button", { name: "Open path" }).click();
-    await waitFor(() => {
-      expect(vi.mocked(openPath)).toHaveBeenCalledWith(
-        "/Users/test/.goose/artifacts/report.md",
-      );
-    });
-  });
-
-  it("falls back from a working-dir artifacts path to the project root when the file lives there", async () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    mockPathExists.mockImplementation(
-      async (path: string) =>
-        path === "/Users/test/project-a/README_ENHANCED.md",
-    );
-
-    render(
-      <ArtifactPolicyProvider
-        messages={[]}
-        allowedRoots={[
-          "/Users/test/project-a/artifacts",
-          "/Users/test/project-a",
-          "/Users/test/.goose/artifacts",
-        ]}
-      >
-        <FallbackProbe path="/Users/test/project-a/artifacts/README_ENHANCED.md" />
-      </ArtifactPolicyProvider>,
-    );
-
-    screen.getByRole("button", { name: "Check path" }).click();
-    await waitFor(() => {
-      expect(
-        (window as Window & { __artifactExists?: boolean }).__artifactExists,
-      ).toBe(true);
-    });
-
-    screen.getByRole("button", { name: "Open path" }).click();
-    await waitFor(() => {
-      expect(vi.mocked(openPath)).toHaveBeenCalledWith(
-        "/Users/test/project-a/README_ENHANCED.md",
-      );
-    });
-  });
-
-  it("does not strip /artifacts/ from a parent directory in the path", async () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    // The file lives at the nested artifacts path — the parent `/artifacts/` should NOT be stripped
-    mockPathExists.mockImplementation(
-      async (path: string) =>
-        path === "/Users/test/artifacts/project/artifacts/README_ENHANCED.md",
-    );
-
-    render(
-      <ArtifactPolicyProvider
-        messages={[]}
-        allowedRoots={[
-          "/Users/test/artifacts/project/artifacts",
-          "/Users/test/artifacts/project",
-          "/Users/test/.goose/artifacts",
-        ]}
-      >
-        <FallbackProbe path="/Users/test/artifacts/project/artifacts/README_ENHANCED.md" />
-      </ArtifactPolicyProvider>,
-    );
-
-    screen.getByRole("button", { name: "Check path" }).click();
-    await waitFor(() => {
-      expect(
-        (window as Window & { __artifactExists?: boolean }).__artifactExists,
-      ).toBe(true);
-    });
-
-    screen.getByRole("button", { name: "Open path" }).click();
-    await waitFor(() => {
-      expect(vi.mocked(openPath)).toHaveBeenCalledWith(
-        "/Users/test/artifacts/project/artifacts/README_ENHANCED.md",
-      );
-    });
-  });
-
-  it("falls back correctly when /artifacts/ appears in a parent dir", async () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    // File is NOT at the artifacts path, but IS at the root-stripped path
-    mockPathExists.mockImplementation(
-      async (path: string) =>
-        path === "/Users/test/artifacts/project/README.md",
-    );
-
-    render(
-      <ArtifactPolicyProvider
-        messages={[]}
-        allowedRoots={[
-          "/Users/test/artifacts/project/artifacts",
-          "/Users/test/artifacts/project",
-          "/Users/test/.goose/artifacts",
-        ]}
-      >
-        <FallbackProbe path="/Users/test/artifacts/project/artifacts/README.md" />
-      </ArtifactPolicyProvider>,
-    );
-
-    screen.getByRole("button", { name: "Check path" }).click();
-    await waitFor(() => {
-      expect(
-        (window as Window & { __artifactExists?: boolean }).__artifactExists,
-      ).toBe(true);
-    });
-
-    screen.getByRole("button", { name: "Open path" }).click();
-    await waitFor(() => {
-      expect(vi.mocked(openPath)).toHaveBeenCalledWith(
-        "/Users/test/artifacts/project/README.md",
-      );
-    });
-  });
-
-  it("uses assistant text after a tool call to populate file actions and the Files tab", () => {
-    mockPathExists.mockReset();
-    vi.mocked(openPath).mockReset();
-    const writeArgs = {};
-    const messages: Message[] = [
-      {
-        id: "assistant-1",
-        role: "assistant",
-        created: Date.now(),
-        metadata: { userVisible: true, agentVisible: true },
-        content: [
-          {
-            type: "toolRequest",
-            id: "tool-1",
-            name: "writing markdown file about alphabet history",
-            arguments: writeArgs,
-            status: "completed",
-          },
-          {
-            type: "toolResponse",
-            id: "tool-1",
-            name: "writing markdown file about alphabet history",
-            result: "completed",
-            isError: false,
-          },
-          {
-            type: "text",
-            text: "The file alpha.md has been created at /Users/test/.goose/artifacts/alpha.md.",
-          },
-        ],
-      },
-    ];
-
-    render(
-      <ArtifactPolicyProvider
-        messages={messages}
-        allowedRoots={["/Users/test/.goose/artifacts"]}
-      >
-        <TextFollowupProbe writeArgs={writeArgs} />
-      </ArtifactPolicyProvider>,
-    );
-
-    expect(screen.getByTestId("text-followup-role")).toHaveTextContent(
-      "primary_host",
-    );
-    expect(screen.getByTestId("text-followup-path")).toHaveTextContent(
-      "/Users/test/.goose/artifacts/alpha.md",
-    );
-    expect(screen.getByTestId("text-followup-artifacts")).toHaveTextContent(
-      "/Users/test/.goose/artifacts/alpha.md",
-    );
-  });
-});
diff --git a/ui/goose2/src/features/chat/hooks/__tests__/ArtifactPolicyContext.tool-card-display.test.tsx b/ui/goose2/src/features/chat/hooks/__tests__/ArtifactPolicyContext.tool-card-display.test.tsx
new file mode 100644
index 000000000000..30aa16e1d8e9
--- /dev/null
+++ b/ui/goose2/src/features/chat/hooks/__tests__/ArtifactPolicyContext.tool-card-display.test.tsx
@@ -0,0 +1,220 @@
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { Message } from "@/shared/types/messages";
+import {
+  ArtifactPolicyProvider,
+  useArtifactPolicyContext,
+} from "../ArtifactPolicyContext";
+
+import { openPath } from "@tauri-apps/plugin-opener";
+
+const mockPathExists = vi.fn<(path: string) => Promise<boolean>>();
+
+vi.mock("@/shared/api/system", () => ({
+  pathExists: (path: string) => mockPathExists(path),
+}));
+
+function Probe({
+  readArgs,
+  writeArgs,
+  clonedWriteArgs,
+}: {
+  readArgs: Record<string, unknown>;
+  writeArgs: Record<string, unknown>;
+  clonedWriteArgs: Record<string, unknown>;
+}) {
+  const { resolveToolCardDisplay } = useArtifactPolicyContext();
+  const readDisplay = resolveToolCardDisplay(readArgs, "read_file");
+  const writeDisplay = resolveToolCardDisplay(writeArgs, "write_file");
+  const clonedDisplay = resolveToolCardDisplay(clonedWriteArgs, "write_file");
+
+  return (
+    <div>
+      <span data-testid="read-role">{readDisplay.role}</span>
+      <span data-testid="write-role">{writeDisplay.role}</span>
+      <span data-testid="write-primary">
+        {writeDisplay.primaryCandidate?.resolvedPath ?? ""}
+      </span>
+      <span data-testid="write-secondary-count">
+        {String(writeDisplay.secondaryCandidates.length)}
+      </span>
+      <span data-testid="write-secondary-paths">
+        {writeDisplay.secondaryCandidates
+          .map((candidate) => candidate.resolvedPath)
+          .join(",")}
+      </span>
+      <span data-testid="cloned-role">{clonedDisplay.role}</span>
+    </div>
+  );
+}
+
+function EditWriteProbe({
+  editArgs,
+  writeArgs,
+}: {
+  editArgs: Record<string, unknown>;
+  writeArgs: Record<string, unknown>;
+}) {
+  const { resolveToolCardDisplay } = useArtifactPolicyContext();
+  const editDisplay = resolveToolCardDisplay(editArgs, "edit_file");
+  const writeDisplay = resolveToolCardDisplay(writeArgs, "write_file");
+
+  return (
+    <div>
+      <span data-testid="edit-role">{editDisplay.role}</span>
+      <span data-testid="write-role">{writeDisplay.role}</span>
+      <span data-testid="write-secondary-paths">
+        {writeDisplay.secondaryCandidates
+          .map((candidate) => candidate.resolvedPath)
+          .join(",")}
+      </span>
+    </div>
+  );
+}
+
+describe("ArtifactPolicyContext tool card display", () => {
+  it("resolves tool card displays per tool call and by args identity", () => {
+    mockPathExists.mockReset();
+    vi.mocked(openPath).mockReset();
+    const readArgs = { path: "/Users/test/project-a/notes.md" };
+    const writeArgs = {
+      paths: [
+        "/Users/test/project-a/output/final_report.md",
+        "/Users/test/project-a/output/notes.md",
+      ],
+    };
+    const messages: Message[] = [
+      {
+        id: "assistant-1",
+        role: "assistant",
+        created: Date.now(),
+        content: [
+          {
+            type: "toolRequest",
+            id: "tool-1",
+            name: "read_file",
+            arguments: readArgs,
+            status: "completed",
+          },
+          {
+            type: "toolResponse",
+            id: "tool-1",
+            name: "read_file",
+            result: "Read /Users/test/project-a/notes.md",
+            isError: false,
+          },
+          {
+            type: "toolRequest",
+            id: "tool-2",
+            name: "write_file",
+            arguments: writeArgs,
+            status: "completed",
+          },
+          {
+            type: "toolResponse",
+            id: "tool-2",
+            name: "write_file",
+            result: "Created /Users/test/project-a/output/final_report.md",
+            isError: false,
+          },
+        ],
+      },
+    ];
+
+    render(
+      <ArtifactPolicyProvider
+        messages={messages}
+        allowedRoots={["/Users/test/project-a", "/Users/test/.goose/artifacts"]}
+      >
+        <Probe
+          readArgs={readArgs}
+          writeArgs={writeArgs}
+          clonedWriteArgs={{ ...writeArgs }}
+        />
+      </ArtifactPolicyProvider>,
+    );
+
+    expect(screen.getByTestId("read-role")).toHaveTextContent("none");
+    expect(screen.getByTestId("write-role")).toHaveTextContent("primary_host");
+    expect(screen.getByTestId("write-primary")).toHaveTextContent(
+      "/Users/test/project-a/output/final_report.md",
+    );
+    expect(
+      Number(screen.getByTestId("write-secondary-count").textContent),
+    ).toBeGreaterThan(0);
+    expect(screen.getByTestId("write-secondary-paths")).toHaveTextContent(
+      "/Users/test/project-a/output/notes.md",
+    );
+    expect(screen.getByTestId("write-secondary-paths")).not.toHaveTextContent(
+      "/Users/test/project-a/notes.md",
+    );
+    expect(screen.getByTestId("cloned-role")).toHaveTextContent("none");
+  });
+
+  it("does not surface artifact actions for edit tool calls in mixed messages", () => {
+    mockPathExists.mockReset();
+    vi.mocked(openPath).mockReset();
+    const editArgs = { path: "/Users/test/project-a/README.md" };
+    const writeArgs = {
+      paths: [
+        "/Users/test/project-a/output/final_report.md",
+        "/Users/test/project-a/output/notes.md",
+      ],
+    };
+    const messages: Message[] = [
+      {
+        id: "assistant-edit-write",
+        role: "assistant",
+        created: Date.now(),
+        content: [
+          {
+            type: "toolRequest",
+            id: "tool-edit",
+            name: "edit_file",
+            arguments: editArgs,
+            status: "completed",
+          },
+          {
+            type: "toolResponse",
+            id: "tool-edit",
+            name: "edit_file",
+            result: "Edited /Users/test/project-a/README.md",
+            isError: false,
+          },
+          {
+            type: "toolRequest",
+            id: "tool-write",
+            name: "write_file",
+            arguments: writeArgs,
+            status: "completed",
+          },
+          {
+            type: "toolResponse",
+            id: "tool-write",
+            name: "write_file",
+            result: "Created /Users/test/project-a/output/final_report.md",
+            isError: false,
+          },
+        ],
+      },
+    ];
+
+    render(
+      <ArtifactPolicyProvider
+        messages={messages}
+        allowedRoots={["/Users/test/project-a", "/Users/test/.goose/artifacts"]}
+      >
+        <EditWriteProbe editArgs={editArgs} writeArgs={writeArgs} />
+      </ArtifactPolicyProvider>,
+    );
+
+    expect(screen.getByTestId("edit-role")).toHaveTextContent("none");
+    expect(screen.getByTestId("write-role")).toHaveTextContent("primary_host");
+    expect(screen.getByTestId("write-secondary-paths")).toHaveTextContent(
+      "/Users/test/project-a/output/notes.md",
+    );
+    expect(screen.getByTestId("write-secondary-paths")).not.toHaveTextContent(
+      "/Users/test/project-a/README.md",
+    );
+  });
+});
diff --git a/ui/goose2/src/features/chat/lib/toolCallPresentation.ts b/ui/goose2/src/features/chat/lib/toolCallPresentation.ts
new file mode 100644
index 000000000000..c540effb07ae
--- /dev/null
+++ b/ui/goose2/src/features/chat/lib/toolCallPresentation.ts
@@ -0,0 +1,190 @@
+import type { ToolCallKind, ToolCallLocation } from "@/shared/types/messages";
+
+const COMMAND_KEYS = ["command", "cmd", "script"];
+const SEARCH_KEYS = ["query", "pattern", "search", "needle", "text"];
+const PATH_KEYS = [
+  "path",
+  "file",
+  "filePath",
+  "filepath",
+  "targetPath",
+  "directory",
+  "dir",
+  "cwd",
+  "folder",
+];
+const URL_KEYS = ["url", "uri", "href"];
+const FILE_ORIENTED_KINDS = new Set<ToolCallKind>([
+  "read",
+  "edit",
+  "delete",
+  "move",
+]);
+
+export interface ToolInputSummaryRow {
+  label: string;
+  value: string;
+  monospace?: boolean;
+  title?: string;
+  renderAs?: "text" | "bash";
+}
+
+interface ToolCallPresentationInput {
+  name: string;
+  kind?: ToolCallKind;
+  locations?: ToolCallLocation[];
+  arguments: Record<string, unknown>;
+}
+
+function getStringArgument(
+  args: Record<string, unknown>,
+  keys: string[],
+): string | undefined {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+
+  return undefined;
+}
+
+function getNumericArgument(
+  args: Record<string, unknown>,
+  keys: string[],
+): number | undefined {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+
+  return undefined;
+}
+
+function looksLikeUrl(value: string): boolean {
+  return /^https?:\/\//i.test(value);
+}
+
+function basenameOf(path: string): string {
+  const normalized = path.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? path;
+}
+
+function getPrimaryPath(
+  args: Record<string, unknown>,
+  locations?: ToolCallLocation[],
+): string | undefined {
+  return getStringArgument(args, PATH_KEYS) ?? locations?.[0]?.path;
+}
+
+export function getToolInputSummaryRows({
+  name,
+  kind,
+  locations,
+  arguments: args,
+}: ToolCallPresentationInput): ToolInputSummaryRow[] {
+  const command = getStringArgument(args, COMMAND_KEYS);
+  if (command) {
+    const cwd = getStringArgument(args, ["cwd"]);
+    return [
+      {
+        label: "Command",
+        value: command,
+        monospace: true,
+        renderAs: "bash",
+      },
+      ...(cwd
+        ? [{ label: "Working directory", value: cwd, monospace: true }]
+        : []),
+    ];
+  }
+
+  const query = getStringArgument(args, SEARCH_KEYS);
+  if (kind === "search" || query) {
+    const path = getPrimaryPath(args, locations);
+    return [
+      ...(query ? [{ label: "Query", value: query, monospace: true }] : []),
+      ...(path ? [{ label: "Path", value: path, monospace: true }] : []),
+    ];
+  }
+
+  const url = getStringArgument(args, URL_KEYS);
+  if (kind === "fetch" || url) {
+    return url ? [{ label: "Resource", value: url, monospace: true }] : [];
+  }
+
+  const path = getPrimaryPath(args, locations);
+  if ((kind && FILE_ORIENTED_KINDS.has(kind)) || path) {
+    const line =
+      getNumericArgument(args, ["line", "startLine"]) ?? locations?.[0]?.line;
+    const displayPath = path ? basenameOf(path) : undefined;
+    return [
+      ...(path
+        ? [
+            {
+              label: "Path",
+              value: displayPath ?? path,
+              monospace: true,
+              title: path,
+            },
+          ]
+        : []),
+      ...(line ? [{ label: "Line", value: String(line) }] : []),
+    ];
+  }
+
+  if (name.trim().length > 0) {
+    return [{ label: "Tool", value: name }];
+  }
+
+  return [];
+}
+
+export function isFileOrientedToolCall({
+  kind,
+  locations,
+  arguments: args,
+}: Omit<ToolCallPresentationInput, "name">): boolean {
+  if (locations && locations.length > 0) {
+    return true;
+  }
+
+  if (kind && FILE_ORIENTED_KINDS.has(kind)) {
+    return true;
+  }
+
+  const path = getStringArgument(args, PATH_KEYS);
+  return Boolean(path && !looksLikeUrl(path));
+}
+
+export function dedupeToolLocations(
+  locations?: ToolCallLocation[],
+): ToolCallLocation[] {
+  if (!locations?.length) {
+    return [];
+  }
+
+  const deduped = new Map<string, ToolCallLocation>();
+  for (const location of locations) {
+    const key = `${location.path}:${location.line ?? ""}`;
+    if (!deduped.has(key)) {
+      deduped.set(key, location);
+    }
+  }
+
+  return Array.from(deduped.values());
+}
+
+export function getToolLocationTitle(location: ToolCallLocation): string {
+  return location.line
+    ? `${basenameOf(location.path)}:${location.line}`
+    : basenameOf(location.path);
+}
+
+export function getToolLocationSubtitle(location: ToolCallLocation): string {
+  return location.line ? `${location.path}:${location.line}` : location.path;
+}
diff --git a/ui/goose2/src/features/chat/ui/MessageBubble.tsx b/ui/goose2/src/features/chat/ui/MessageBubble.tsx
index ce1d3c74575d..cf7bbc0cedce 100644
--- a/ui/goose2/src/features/chat/ui/MessageBubble.tsx
+++ b/ui/goose2/src/features/chat/ui/MessageBubble.tsx
@@ -1,30 +1,18 @@
 import { memo } from "react";
 import { useTranslation } from "react-i18next";
-import {
-  Copy,
-  Check,
-  RotateCcw,
-  Pencil,
-  FileText,
-  FolderClosed,
-} from "lucide-react";
+import { Check, FileText, FolderClosed } from "lucide-react";
 import { IconRobot } from "@tabler/icons-react";
 import { openPath } from "@tauri-apps/plugin-opener";
 import { cn } from "@/shared/lib/cn";
 import { useLocaleFormatting } from "@/shared/i18n";
 import { useAgentStore } from "@/features/agents/stores/agentStore";
-import { useCopyToClipboard } from "@/hooks/use-copy-to-clipboard";
 import { getCatalogEntry } from "@/features/providers/providerCatalog";
 import {
   getProviderIcon,
   formatProviderLabel,
 } from "@/shared/ui/icons/ProviderIcons";
 import { useAvatarSrc } from "@/shared/hooks/useAvatarSrc";
-import {
-  MessageActions,
-  MessageAction,
-  MessageResponse,
-} from "@/shared/ui/ai-elements/message";
+import { MessageResponse } from "@/shared/ui/ai-elements/message";
 import {
   Reasoning,
   ReasoningTrigger,
@@ -32,6 +20,7 @@ import {
 } from "@/shared/ui/ai-elements/reasoning";
 import { ToolChainCards, type ToolChainItem } from "./ToolChainCards";
 import { ClickableImage } from "./ClickableImage";
+import { MessageBubbleActions } from "./MessageBubbleActions";
 import { useArtifactLinkHandler } from "@/features/chat/hooks/useArtifactLinkHandler";
 import type {
   Message,
@@ -97,11 +86,10 @@ interface ContentSection {
   items: MessageContent[] | ToolChainItem[];
 }
 
-/** Keep only content blocks whose audience includes "user" (or has no audience). */
 function filterUserVisibleContent(content: MessageContent[]): MessageContent[] {
-  return content.filter((b) => {
-    const aud = b.annotations?.audience;
-    return !aud || aud.length === 0 || aud.includes("user");
+  return content.filter((block) => {
+    const audience = block.annotations?.audience;
+    return !audience || audience.length === 0 || audience.includes("user");
   });
 }
 
@@ -138,7 +126,7 @@ function groupContentSections(content: MessageContent[]): ContentSection[] {
   const flushToolChain = () => {
     if (currentToolChain.length > 0) {
       sections.push({
-        key: currentToolChain.map((item) => item.key).join(":"),
+        key: currentToolChain[0]?.key ?? `tool-chain-${sections.length}`,
         type: "toolChain",
         items: [...currentToolChain],
       });
@@ -232,17 +220,29 @@ function renderContentBlock(
     case "toolResponse":
       // Handled by groupContentSections toolChain rendering
       return null;
-    case "thinking":
+    case "thinking": {
+      const th = content as ThinkingContent;
+      return (
+        <Reasoning
+          key={`thinking-${index}`}
+          isStreaming={isStreamingMsg}
+          defaultOpen={false}
+        >
+          <ReasoningTrigger />
+          <ReasoningContent>{th.text}</ReasoningContent>
+        </Reasoning>
+      );
+    }
     case "reasoning": {
-      const text = (content as ThinkingContent | ReasoningContentType).text;
+      const r = content as ReasoningContentType;
       return (
         <Reasoning
-          key={`${content.type}-${index}`}
+          key={`reasoning-${index}`}
           isStreaming={isStreamingMsg}
           defaultOpen={false}
         >
           <ReasoningTrigger />
-          <ReasoningContent>{text}</ReasoningContent>
+          <ReasoningContent>{r.text}</ReasoningContent>
         </Reasoning>
       );
     }
@@ -281,31 +281,6 @@ function renderContentBlock(
   }
 }
 
-function CopyAction({
-  copied,
-  onCopy,
-}: {
-  copied: boolean;
-  onCopy: () => void;
-}) {
-  const { t } = useTranslation(["chat", "common"]);
-
-  return (
-    <MessageAction
-      size="xs"
-      variant="ghost-light"
-      className={cn(
-        "text-muted-foreground",
-        copied && "bg-accent text-foreground hover:bg-accent active:bg-accent",
-      )}
-      tooltip={copied ? t("message.copied") : t("common:actions.copy")}
-      onClick={onCopy}
-    >
-      {copied ? <Check className="size-3.5" /> : <Copy className="size-3.5" />}
-    </MessageAction>
-  );
-}
-
 export const MessageBubble = memo(function MessageBubble({
   message,
   isStreaming,
@@ -315,21 +290,16 @@ export const MessageBubble = memo(function MessageBubble({
   const { t } = useTranslation(["chat", "common"]);
   const { formatDate } = useLocaleFormatting();
   const { role, content: rawContent, created } = message;
-  // Only user messages carry annotated blocks; skip the filter for others.
   const content =
-    role === "user" ? filterUserVisibleContent(rawContent) : rawContent;
+    role === "system" ? rawContent : filterUserVisibleContent(rawContent);
   const { handleContentClick, pathNotice } = useArtifactLinkHandler();
   const persona = useAgentStore((state) =>
     message.metadata?.personaId
       ? state.getPersonaById(message.metadata.personaId)
       : undefined,
   );
-  const { isCopied: isCopyConfirmed, copyToClipboard } = useCopyToClipboard();
   const personaAvatarUrl = useAvatarSrc(persona?.avatar);
 
-  // Skip empty user bubbles (all blocks filtered as assistant-only).
-  if (role === "user" && content.length === 0) return null;
-
   const textContent = content
     .filter((c): c is TextContent => c.type === "text")
     .map((c) => c.text)
@@ -349,7 +319,18 @@ export const MessageBubble = memo(function MessageBubble({
       </div>
     );
   }
+
+  const messageAttachments = message.metadata?.attachments ?? [];
+  if (content.length === 0 && messageAttachments.length === 0) {
+    return null;
+  }
+
   const isUser = role === "user";
+  const hasToolContent = content.some(
+    (block) => block.type === "toolRequest" || block.type === "toolResponse",
+  );
+  const showAssistantActions = !isUser && !hasToolContent;
+  const showMessageActions = isUser || showAssistantActions;
   const assistantProviderId = message.metadata?.providerId;
   const assistantProviderName = assistantProviderId
     ? (getCatalogEntry(assistantProviderId)?.displayName ??
@@ -366,7 +347,6 @@ export const MessageBubble = memo(function MessageBubble({
     !isUser &&
       (assistantDisplayName || personaAvatarUrl || assistantProviderIcon),
   );
-  const messageAttachments = message.metadata?.attachments ?? [];
   const timestamp = (
     <span
       data-role="message-timestamp"
@@ -390,8 +370,9 @@ export const MessageBubble = memo(function MessageBubble({
     >
       <div
         className={cn(
-          "group relative min-w-0 flex flex-col gap-1 pb-8",
-          isUser ? "max-w-[640px] items-end" : "w-full items-start",
+          "group relative min-w-0 flex flex-col gap-1",
+          showMessageActions && "pb-8",
+          isUser ? "max-w-[640px] items-end" : "max-w-[85%] items-start",
         )}
       >
         {showAssistantIdentity ? (
@@ -423,7 +404,7 @@ export const MessageBubble = memo(function MessageBubble({
         {/* biome-ignore lint/a11y/noStaticElementInteractions: delegated link handler */}
         <div
           className={cn(
-            "w-full min-w-0 text-sm leading-relaxed",
+            "w-full min-w-0 text-[13px] leading-relaxed",
             isUser && "rounded-2xl bg-muted p-3",
           )}
           onClick={handleContentClick}
@@ -466,51 +447,16 @@ export const MessageBubble = memo(function MessageBubble({
           )}
         </div>
 
-        <div
-          data-role="message-actions"
-          data-copy-confirmed={isCopyConfirmed ? "true" : "false"}
-          className={cn(
-            "absolute bottom-0 transition-opacity duration-150 ease-out",
-            "opacity-0 pointer-events-none",
-            "group-hover:animate-in group-hover:slide-in-from-top-2 group-hover:opacity-100 group-hover:pointer-events-auto",
-            "group-focus-within:animate-in group-focus-within:slide-in-from-top-2 group-focus-within:opacity-100 group-focus-within:pointer-events-auto",
-            isCopyConfirmed && "opacity-100 pointer-events-auto",
-            isUser ? "right-0" : "left-0",
-          )}
-        >
-          <MessageActions className="pt-0">
-            {isUser && timestamp}
-            {textContent && (
-              <CopyAction
-                copied={isCopyConfirmed}
-                onCopy={() => copyToClipboard(textContent)}
-              />
-            )}
-            {!isUser && onRetryMessage && (
-              <MessageAction
-                size="xs"
-                variant="ghost-light"
-                className="text-muted-foreground"
-                tooltip={t("common:actions.retry")}
-                onClick={() => onRetryMessage(message.id)}
-              >
-                <RotateCcw className="size-3.5" />
-              </MessageAction>
-            )}
-            {isUser && onEditMessage && (
-              <MessageAction
-                size="xs"
-                variant="ghost-light"
-                className="text-muted-foreground"
-                tooltip={t("common:actions.edit")}
-                onClick={() => onEditMessage(message.id)}
-              >
-                <Pencil className="size-3.5" />
-              </MessageAction>
-            )}
-            {!isUser && timestamp}
-          </MessageActions>
-        </div>
+        {showMessageActions && (
+          <MessageBubbleActions
+            isUser={isUser}
+            messageId={message.id}
+            textContent={textContent}
+            timestamp={timestamp}
+            onRetryMessage={onRetryMessage}
+            onEditMessage={onEditMessage}
+          />
+        )}
       </div>
     </div>
   );
diff --git a/ui/goose2/src/features/chat/ui/MessageBubbleActions.tsx b/ui/goose2/src/features/chat/ui/MessageBubbleActions.tsx
new file mode 100644
index 000000000000..0c82e1fd6f9f
--- /dev/null
+++ b/ui/goose2/src/features/chat/ui/MessageBubbleActions.tsx
@@ -0,0 +1,100 @@
+import { useTranslation } from "react-i18next";
+import { Copy, Check, RotateCcw, Pencil } from "lucide-react";
+import type { ReactNode } from "react";
+import { cn } from "@/shared/lib/cn";
+import { useCopyToClipboard } from "@/hooks/use-copy-to-clipboard";
+import { MessageActions, MessageAction } from "@/shared/ui/ai-elements/message";
+
+function CopyAction({
+  copied,
+  onCopy,
+}: {
+  copied: boolean;
+  onCopy: () => void;
+}) {
+  const { t } = useTranslation(["chat", "common"]);
+
+  return (
+    <MessageAction
+      size="xs"
+      variant="ghost-light"
+      className={cn(
+        "text-muted-foreground",
+        copied && "bg-accent text-foreground hover:bg-accent active:bg-accent",
+      )}
+      tooltip={copied ? t("message.copied") : t("common:actions.copy")}
+      onClick={onCopy}
+    >
+      {copied ? <Check className="size-3.5" /> : <Copy className="size-3.5" />}
+    </MessageAction>
+  );
+}
+
+interface MessageBubbleActionsProps {
+  isUser: boolean;
+  messageId: string;
+  textContent: string;
+  timestamp: ReactNode;
+  onRetryMessage?: (messageId: string) => void;
+  onEditMessage?: (messageId: string) => void;
+}
+
+export function MessageBubbleActions({
+  isUser,
+  messageId,
+  textContent,
+  timestamp,
+  onRetryMessage,
+  onEditMessage,
+}: MessageBubbleActionsProps) {
+  const { t } = useTranslation(["chat", "common"]);
+  const { isCopied, copyToClipboard } = useCopyToClipboard();
+
+  return (
+    <div
+      data-role="message-actions"
+      data-copy-confirmed={isCopied ? "true" : "false"}
+      className={cn(
+        "absolute bottom-0 transition-opacity duration-150 ease-out",
+        "opacity-0 pointer-events-none",
+        "group-hover:animate-in group-hover:slide-in-from-top-2 group-hover:opacity-100 group-hover:pointer-events-auto",
+        "group-focus-within:animate-in group-focus-within:slide-in-from-top-2 group-focus-within:opacity-100 group-focus-within:pointer-events-auto",
+        isCopied && "opacity-100 pointer-events-auto",
+        isUser ? "right-0" : "left-0",
+      )}
+    >
+      <MessageActions className="pt-0">
+        {isUser && timestamp}
+        {textContent && (
+          <CopyAction
+            copied={isCopied}
+            onCopy={() => copyToClipboard(textContent)}
+          />
+        )}
+        {!isUser && onRetryMessage && (
+          <MessageAction
+            size="xs"
+            variant="ghost-light"
+            className="text-muted-foreground"
+            tooltip={t("common:actions.retry")}
+            onClick={() => onRetryMessage(messageId)}
+          >
+            <RotateCcw className="size-3.5" />
+          </MessageAction>
+        )}
+        {isUser && onEditMessage && (
+          <MessageAction
+            size="xs"
+            variant="ghost-light"
+            className="text-muted-foreground"
+            tooltip={t("common:actions.edit")}
+            onClick={() => onEditMessage(messageId)}
+          >
+            <Pencil className="size-3.5" />
+          </MessageAction>
+        )}
+        {!isUser && timestamp}
+      </MessageActions>
+    </div>
+  );
+}
diff --git a/ui/goose2/src/features/chat/ui/MessageTimeline.tsx b/ui/goose2/src/features/chat/ui/MessageTimeline.tsx
index fdf3777c0273..4a2cab9a8b19 100644
--- a/ui/goose2/src/features/chat/ui/MessageTimeline.tsx
+++ b/ui/goose2/src/features/chat/ui/MessageTimeline.tsx
@@ -187,8 +187,7 @@ export function MessageTimeline({
                 messageRefs.current[message.id] = el;
               }}
               className={cn(
-                index === 0 ? "mt-0" : "mt-4",
-                "rounded-xl transition-[background-color,box-shadow]",
+                "transition-[background-color,box-shadow]",
                 pulsingMessageId === message.id &&
                   "bg-accent/25 ring-2 ring-accent/35 ring-inset",
               )}
diff --git a/ui/goose2/src/features/chat/ui/ToolCallAdapter.tsx b/ui/goose2/src/features/chat/ui/ToolCallAdapter.tsx
index 3701c529441b..a6ece6783bd8 100644
--- a/ui/goose2/src/features/chat/ui/ToolCallAdapter.tsx
+++ b/ui/goose2/src/features/chat/ui/ToolCallAdapter.tsx
@@ -1,30 +1,52 @@
 import { useState, useEffect, useMemo } from "react";
 import { useTranslation } from "react-i18next";
-import { FolderOpen, ChevronRight } from "lucide-react";
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
+import { FolderOpen, ChevronRight, FileText } from "lucide-react";
 import { cn } from "@/shared/lib/cn";
 import { Button } from "@/shared/ui/button";
+import { CodeBlock } from "@/shared/ui/ai-elements/code-block";
 import {
   Tool,
   ToolHeader,
   ToolContent,
   ToolInput,
   ToolOutput,
+  ToolSection,
+  ToolSurface,
 } from "@/shared/ui/ai-elements/tool";
 import { toolStatusMap } from "../lib/toolStatusMap";
-import type { ToolCallStatus } from "@/shared/types/messages";
+import type {
+  ToolCallKind,
+  ToolCallLocation,
+  ToolCallStructuredContent,
+  ToolCallStatus,
+} from "@/shared/types/messages";
 import { useArtifactPolicyContext } from "@/features/chat/hooks/ArtifactPolicyContext";
 import type { ArtifactPathCandidate } from "@/features/chat/lib/artifactPathPolicy";
+import {
+  dedupeToolLocations,
+  getToolInputSummaryRows,
+  getToolLocationSubtitle,
+  getToolLocationTitle,
+  isFileOrientedToolCall,
+} from "../lib/toolCallPresentation";
 
 interface ToolCallAdapterProps {
   name: string;
   arguments: Record<string, unknown>;
+  kind?: ToolCallKind;
+  locations?: ToolCallLocation[];
   status: ToolCallStatus;
   result?: string;
+  content?: ToolCallStructuredContent[];
+  rawOutput?: unknown;
   isError?: boolean;
   /** Epoch ms when the tool call started executing. */
   startedAt?: number;
   open?: boolean;
   onOpenChange?: (open: boolean) => void;
+  showStatusBadge?: boolean;
+  fitWidth?: boolean;
 }
 
 function useElapsedTime(status: ToolCallStatus, startedAt?: number) {
@@ -46,6 +68,116 @@ function useElapsedTime(status: ToolCallStatus, startedAt?: number) {
   return elapsed;
 }
 
+function InputSummary({
+  rows,
+  isOpen,
+}: {
+  rows: ReturnType<typeof getToolInputSummaryRows>;
+  isOpen: boolean;
+}) {
+  const commandCodeBlockClasses =
+    "rounded-none border-0 bg-transparent shadow-none [&>div]:overflow-hidden [&_pre]:m-0 [&_pre]:bg-transparent [&_pre]:p-0 [&_pre]:whitespace-pre-wrap [&_pre]:break-words [&_pre]:text-[12px] [&_pre]:leading-5 [&_code]:font-mono [&_code]:text-[12px] [&_code]:leading-5";
+
+  if (rows.length === 0) {
+    return null;
+  }
+
+  return (
+    <div className="space-y-2">
+      {rows.map((row) => (
+        <div key={`${row.label}-${row.value}`} className="max-w-full">
+          {row.renderAs === "bash" ? (
+            <div className="space-y-0.5">
+              <div className="text-[11px] uppercase tracking-wide text-muted-foreground">
+                {row.label}
+              </div>
+              <CodeBlock
+                code={row.value}
+                language="bash"
+                data-tool-command-preview={!isOpen ? "" : undefined}
+                className={cn(
+                  commandCodeBlockClasses,
+                  !isOpen && "[&_pre]:line-clamp-3 [&_pre]:overflow-hidden",
+                )}
+              />
+            </div>
+          ) : (
+            <div className="space-y-0.5">
+              <div className="text-[11px] uppercase tracking-wide text-muted-foreground">
+                {row.label}
+              </div>
+              <div
+                title={row.title}
+                className={cn(
+                  "block min-w-0 break-words text-[13px] text-foreground",
+                  row.monospace && "font-mono text-[12px]",
+                )}
+              >
+                {row.value}
+              </div>
+            </div>
+          )}
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function ToolLocations({ locations }: { locations: ToolCallLocation[] }) {
+  const { t } = useTranslation("chat");
+  const { pathExists, openResolvedPath, resolveMarkdownHref } =
+    useArtifactPolicyContext();
+  const [openError, setOpenError] = useState<string | null>(null);
+
+  const openLocation = async (path: string) => {
+    try {
+      setOpenError(null);
+      const candidate = resolveMarkdownHref(path);
+      if (!candidate?.allowed) {
+        setOpenError(candidate?.blockedReason || t("tools.pathOutsideRoots"));
+        return;
+      }
+
+      const exists = await pathExists(candidate.resolvedPath);
+      if (!exists) {
+        setOpenError(t("tools.fileNotFound", { path: candidate.resolvedPath }));
+        return;
+      }
+      await openResolvedPath(candidate.resolvedPath);
+    } catch (error) {
+      setOpenError(error instanceof Error ? error.message : String(error));
+    }
+  };
+
+  return (
+    <ToolSection label="Files">
+      <div className="flex flex-wrap gap-1.5">
+        {locations.map((location) => {
+          const candidate = resolveMarkdownHref(location.path);
+
+          return (
+            <Button
+              key={`${location.path}:${location.line ?? ""}`}
+              type="button"
+              variant="outline-flat"
+              onClick={() => void openLocation(location.path)}
+              className="inline-flex h-auto max-w-full items-center justify-start rounded-full px-2.5 py-1 text-xs"
+              title={getToolLocationSubtitle(location)}
+              disabled={!candidate?.allowed}
+            >
+              <FileText className="h-3.5 w-3.5 shrink-0" />
+              <span className="truncate">{getToolLocationTitle(location)}</span>
+            </Button>
+          );
+        })}
+      </div>
+      {openError ? (
+        <p className="text-[11px] text-destructive">{openError}</p>
+      ) : null}
+    </ToolSection>
+  );
+}
+
 function ArtifactActions({
   args,
   name,
@@ -116,7 +248,7 @@ function ArtifactActions({
   };
 
   return (
-    <div className="mt-1.5 ml-1 space-y-1.5">
+    <div className="space-y-1.5">
       <Button
         type="button"
         variant="outline-flat"
@@ -139,7 +271,7 @@ function ArtifactActions({
         </span>
       </Button>
       {!primary.allowed && primary.blockedReason && (
-        <p className="text-[11px] text-destructive ml-1">
+        <p className="ml-1 text-[11px] text-destructive">
           {primary.blockedReason}
         </p>
       )}
@@ -203,42 +335,165 @@ function ArtifactActions({
   );
 }
 
+function splitHeaderTitle(name: string, fileLabel: string) {
+  const index = name.toLowerCase().lastIndexOf(fileLabel.toLowerCase());
+  if (index === -1) {
+    return null;
+  }
+
+  return {
+    prefix: name.slice(0, index),
+    fileLabel: name.slice(index, index + fileLabel.length),
+    suffix: name.slice(index + fileLabel.length),
+  };
+}
+
 export function ToolCallAdapter({
   name,
   arguments: args,
+  kind,
+  locations,
   status,
   result,
+  rawOutput,
   isError,
   startedAt,
   open,
   onOpenChange,
+  showStatusBadge = true,
+  fitWidth = false,
 }: ToolCallAdapterProps) {
   const elapsed = useElapsedTime(status, startedAt);
   const state = toolStatusMap[status];
+  const [isToolOpen, setIsToolOpen] = useControllableState({
+    prop: open,
+    defaultProp: false,
+    onChange: onOpenChange,
+  });
+  const summaryRows = useMemo(
+    () => getToolInputSummaryRows({ name, kind, locations, arguments: args }),
+    [args, kind, locations, name],
+  );
+  const visibleLocations = useMemo(
+    () => dedupeToolLocations(locations),
+    [locations],
+  );
+  const isFileOriented = isFileOrientedToolCall({
+    kind,
+    locations: visibleLocations,
+    arguments: args,
+  });
+  const { openResolvedPath, resolveMarkdownHref } = useArtifactPolicyContext();
+  const rawResult =
+    result ??
+    (typeof rawOutput === "string"
+      ? rawOutput
+      : rawOutput != null
+        ? JSON.stringify(rawOutput, null, 2)
+        : undefined);
 
   const elapsedSeconds =
     status === "executing" && elapsed >= 3 ? elapsed : undefined;
+  const pathSummaryRow = summaryRows.find((row) => row.label === "Path");
+  const headerFileLabel = pathSummaryRow?.value;
+  const headerFilePath = pathSummaryRow?.title ?? pathSummaryRow?.value;
+  const headerTitleParts =
+    headerFileLabel && headerFilePath
+      ? splitHeaderTitle(name, headerFileLabel)
+      : null;
+  const headerFileCandidate = useMemo(
+    () => (headerFilePath ? resolveMarkdownHref(headerFilePath) : null),
+    [headerFilePath, resolveMarkdownHref],
+  );
+  const canOpenHeaderFile = Boolean(
+    headerTitleParts && headerFileCandidate?.allowed,
+  );
 
   return (
-    <div>
-      <Tool open={open} onOpenChange={onOpenChange}>
+    <div className={cn(fitWidth && "inline-flex max-w-full flex-col")}>
+      <Tool
+        open={isToolOpen}
+        onOpenChange={setIsToolOpen}
+        className={cn(fitWidth && "inline-flex w-auto max-w-full flex-col")}
+      >
         <ToolHeader
           type="dynamic-tool"
           toolName={name}
-          title={name}
+          title={
+            headerTitleParts ? (
+              <>
+                <span data-tool-title-prefix>{headerTitleParts.prefix}</span>
+                {canOpenHeaderFile ? (
+                  <button
+                    type="button"
+                    data-clickable-file
+                    onClick={(event) => {
+                      event.stopPropagation();
+                      if (!headerFileCandidate?.allowed) {
+                        return;
+                      }
+                      void openResolvedPath(
+                        headerFileCandidate.resolvedPath,
+                      ).catch(() => {});
+                    }}
+                    onKeyDown={(event) => {
+                      event.stopPropagation();
+                    }}
+                    title={headerFileCandidate?.resolvedPath ?? headerFilePath}
+                    aria-label={`Open ${headerTitleParts.fileLabel}`}
+                    className="inline truncate text-foreground underline-offset-2 hover:underline"
+                  >
+                    {headerTitleParts.fileLabel}
+                  </button>
+                ) : (
+                  <span>{headerTitleParts.fileLabel}</span>
+                )}
+                <span>{headerTitleParts.suffix}</span>
+              </>
+            ) : (
+              name
+            )
+          }
+          splitTrigger={canOpenHeaderFile}
           state={state}
           showIcon={false}
+          showStatusBadge={showStatusBadge}
           elapsedSeconds={elapsedSeconds}
+          layout={fitWidth ? "fit" : "fill"}
         />
         <ToolContent>
-          {Object.keys(args).length > 0 && <ToolInput input={args} />}
-          <ToolOutput
-            output={isError ? undefined : result}
-            errorText={isError ? result : undefined}
-          />
+          <ToolSurface tone="muted" className="overflow-hidden bg-muted">
+            <ToolInput
+              input={args}
+              showLabel={false}
+              embedded
+              summary={({ isOpen }) => (
+                <InputSummary rows={summaryRows} isOpen={isOpen} />
+              )}
+            />
+            {isFileOriented ? (
+              <ToolOutput
+                output={isError ? undefined : rawResult}
+                errorText={isError ? result : undefined}
+                showLabel={false}
+                embedded
+                tone="muted"
+              />
+            ) : (
+              <ToolOutput
+                output={isError ? undefined : result}
+                errorText={isError ? result : undefined}
+                showLabel={false}
+                embedded
+              />
+            )}
+          </ToolSurface>
+          {isFileOriented && visibleLocations.length > 1 ? (
+            <ToolLocations locations={visibleLocations} />
+          ) : null}
+          <ArtifactActions args={args} name={name} result={result} />
         </ToolContent>
       </Tool>
-      <ArtifactActions args={args} name={name} result={result} />
     </div>
   );
 }
diff --git a/ui/goose2/src/features/chat/ui/ToolChainCards.tsx b/ui/goose2/src/features/chat/ui/ToolChainCards.tsx
index 5ad7cc0a80fe..f705edb65ac6 100644
--- a/ui/goose2/src/features/chat/ui/ToolChainCards.tsx
+++ b/ui/goose2/src/features/chat/ui/ToolChainCards.tsx
@@ -1,8 +1,16 @@
 import { useState } from "react";
-import { ChevronRight } from "lucide-react";
+import { Check, ChevronRight } from "lucide-react";
 import { cn } from "@/shared/lib/cn";
 import { ToolCallAdapter } from "./ToolCallAdapter";
+import { toolStatusMap } from "../lib/toolStatusMap";
+import {
+  Tool,
+  ToolContent,
+  ToolHeader,
+  ToolStatusIcon,
+} from "@/shared/ui/ai-elements/tool";
 import type {
+  ToolCallStatus,
   ToolRequestContent,
   ToolResponseContent,
 } from "@/shared/types/messages";
@@ -13,6 +21,12 @@ export interface ToolChainItem {
   response?: ToolResponseContent;
 }
 
+interface ToolItemGroup {
+  key: string;
+  chainId?: string;
+  items: ToolChainItem[];
+}
+
 const INTERNAL_TOOL_PREFIXES = new Set([
   "awk",
   "bash",
@@ -39,11 +53,19 @@ const INTERNAL_TOOL_PREFIXES = new Set([
   "zsh",
 ]);
 
+function getToolItemChainId(item: ToolChainItem): string | undefined {
+  return item.request?.chainId ?? item.response?.chainId;
+}
+
 function getToolItemName(item: ToolChainItem): string {
   return item.request?.name || item.response?.name || "Tool result";
 }
 
-function getToolItemStatus(item: ToolChainItem) {
+function getToolItemChainSummary(item: ToolChainItem): string | undefined {
+  return item.response?.chainSummary ?? item.request?.chainSummary;
+}
+
+function getToolItemStatus(item: ToolChainItem): ToolCallStatus {
   if (item.response) {
     return item.response.isError ? "error" : "completed";
   }
@@ -104,10 +126,82 @@ function partitionToolSteps(toolItems: ToolChainItem[]) {
   return { primaryItems, hiddenItems };
 }
 
+function groupToolItems(toolItems: ToolChainItem[]): ToolItemGroup[] {
+  const groups: ToolItemGroup[] = [];
+
+  for (const item of toolItems) {
+    const chainId = getToolItemChainId(item);
+    const currentGroup = groups[groups.length - 1];
+
+    if (currentGroup && currentGroup.chainId === chainId) {
+      currentGroup.items.push(item);
+      continue;
+    }
+
+    groups.push({
+      key: chainId ? `chain-${chainId}-${item.key}` : `group-${item.key}`,
+      chainId,
+      items: [item],
+    });
+  }
+
+  return groups;
+}
+
+function getToolGroupTitle(toolItems: ToolChainItem[]): string {
+  for (let index = toolItems.length - 1; index >= 0; index -= 1) {
+    const chainSummary = getToolItemChainSummary(toolItems[index]);
+    if (chainSummary) {
+      return chainSummary;
+    }
+  }
+
+  const displayItem =
+    toolItems.find((item) => !isLowSignalToolStep(item)) ?? toolItems[0];
+  return getToolItemName(displayItem);
+}
+
+function getToolGroupStatus(toolItems: ToolChainItem[]): ToolCallStatus {
+  if (toolItems.some((item) => getToolItemStatus(item) === "error")) {
+    return "error";
+  }
+  if (toolItems.some((item) => getToolItemStatus(item) === "stopped")) {
+    return "stopped";
+  }
+  if (toolItems.some((item) => getToolItemStatus(item) === "executing")) {
+    return "executing";
+  }
+  if (toolItems.some((item) => getToolItemStatus(item) === "pending")) {
+    return "pending";
+  }
+  return "completed";
+}
+
+function formatToolGroupTitle(
+  title: string,
+  stepCount: number,
+  status: ToolCallStatus,
+): string {
+  if (title === "working" || status === "pending" || status === "executing") {
+    return `working through ${stepCount} ${stepCount === 1 ? "step" : "steps"}`;
+  }
+
+  return `${title} (${stepCount} ${stepCount === 1 ? "step" : "steps"})`;
+}
+
+function shouldShowGroupedChain(group: ToolItemGroup): boolean {
+  return Boolean(group.chainId);
+}
+
 export function ToolChainCards({ toolItems }: { toolItems: ToolChainItem[] }) {
-  const [showInternalSteps, setShowInternalSteps] = useState(false);
+  const [showInternalStepGroups, setShowInternalStepGroups] = useState<
+    Set<string>
+  >(new Set());
   const [expandedKeys, setExpandedKeys] = useState<Set<string>>(new Set());
-  const { primaryItems, hiddenItems } = partitionToolSteps(toolItems);
+  const [expandedChainOverrides, setExpandedChainOverrides] = useState<
+    Record<string, boolean>
+  >({});
+  const groups = groupToolItems(toolItems);
 
   const handleOpenChange = (key: string, open: boolean) => {
     setExpandedKeys((prev) => {
@@ -121,51 +215,183 @@ export function ToolChainCards({ toolItems }: { toolItems: ToolChainItem[] }) {
     });
   };
 
-  const renderToolItem = (item: ToolChainItem) => {
+  const handleShowInternalStepsChange = (groupKey: string) => {
+    setShowInternalStepGroups((prev) => {
+      const next = new Set(prev);
+      if (next.has(groupKey)) {
+        next.delete(groupKey);
+      } else {
+        next.add(groupKey);
+      }
+      return next;
+    });
+  };
+
+  const handleChainOpenChange = (groupKey: string, open: boolean) => {
+    setExpandedChainOverrides((prev) => ({
+      ...prev,
+      [groupKey]: open,
+    }));
+  };
+
+  const renderToolItem = (
+    item: ToolChainItem,
+    itemIndex: number,
+    totalItems: number,
+  ) => {
     const name = getToolItemName(item);
     const status = getToolItemStatus(item);
     const { request, response } = item;
+    const isLast = itemIndex === totalItems - 1;
+    const isCompleted = status === "completed";
+
+    return (
+      <div key={item.key} className="flex max-w-full items-start gap-2.5">
+        <div className="relative flex w-4 shrink-0 justify-center self-stretch">
+          <div className="pointer-events-none absolute top-0 left-1/2 h-0.5 w-px -translate-x-1/2 bg-border" />
+          {!isLast && (
+            <div className="pointer-events-none absolute top-[1.375rem] bottom-[-0.5rem] left-1/2 w-px -translate-x-1/2 bg-border" />
+          )}
+          <div className="relative z-10 mt-1 flex h-4 w-4 items-center justify-center rounded-full bg-background ring-2 ring-background">
+            {isCompleted ? (
+              <Check
+                aria-hidden="true"
+                className="size-4 shrink-0 text-muted-foreground"
+              />
+            ) : (
+              <ToolStatusIcon
+                status={toolStatusMap[status]}
+                className={cn(
+                  status !== "error" &&
+                    status !== "stopped" &&
+                    "text-muted-foreground",
+                )}
+              />
+            )}
+          </div>
+        </div>
+        <div className="inline-flex min-w-0 max-w-full flex-col">
+          <ToolCallAdapter
+            name={name}
+            arguments={request?.arguments ?? {}}
+            kind={response?.kind ?? request?.kind}
+            locations={response?.locations ?? request?.locations}
+            status={status}
+            result={response?.result}
+            content={response?.content ?? request?.content}
+            rawOutput={response?.rawOutput ?? request?.rawOutput}
+            isError={response?.isError}
+            startedAt={request?.startedAt}
+            open={expandedKeys.has(item.key)}
+            onOpenChange={(open) => handleOpenChange(item.key, open)}
+            showStatusBadge={false}
+            fitWidth
+          />
+        </div>
+      </div>
+    );
+  };
+
+  const renderToolItems = (
+    items: ToolChainItem[],
+    startIndex = 0,
+    totalItems = items.length,
+  ) =>
+    items.map((item, index) =>
+      renderToolItem(item, startIndex + index, totalItems),
+    );
+
+  const renderToolStepList = (groupKey: string, items: ToolChainItem[]) => {
+    const { primaryItems, hiddenItems } = partitionToolSteps(items);
+    const showInternalSteps = showInternalStepGroups.has(groupKey);
+    const visibleItemCount = showInternalSteps
+      ? primaryItems.length + hiddenItems.length
+      : primaryItems.length;
 
     return (
-      <ToolCallAdapter
-        key={item.key}
-        name={name}
-        arguments={request?.arguments ?? {}}
-        status={status}
-        result={response?.result}
-        isError={response?.isError}
-        startedAt={request?.startedAt}
-        open={expandedKeys.has(item.key)}
-        onOpenChange={(open) => handleOpenChange(item.key, open)}
-      />
+      <>
+        {renderToolItems(primaryItems, 0, visibleItemCount)}
+
+        {hiddenItems.length > 0 && (
+          <div className="ml-6 flex flex-col items-start gap-1.5">
+            <button
+              type="button"
+              onClick={() => handleShowInternalStepsChange(groupKey)}
+              className="inline-flex items-center gap-1 text-xs text-muted-foreground hover:text-muted-foreground"
+            >
+              <ChevronRight
+                className={cn(
+                  "h-3 w-3 transition-transform",
+                  showInternalSteps && "rotate-90",
+                )}
+              />
+              {showInternalSteps
+                ? `Hide internal steps (${hiddenItems.length})`
+                : `Show internal steps (${hiddenItems.length})`}
+            </button>
+
+            {showInternalSteps &&
+              renderToolItems(
+                hiddenItems,
+                primaryItems.length,
+                visibleItemCount,
+              )}
+          </div>
+        )}
+      </>
     );
   };
 
   return (
-    <div className="my-1 flex flex-col items-start gap-3">
-      {primaryItems.map((item) => renderToolItem(item))}
-
-      {hiddenItems.length > 0 && (
-        <div className="ml-1 flex flex-col items-start gap-1.5">
-          <button
-            type="button"
-            onClick={() => setShowInternalSteps((prev) => !prev)}
-            className="inline-flex items-center gap-1 text-xs text-muted-foreground hover:text-muted-foreground"
+    <div className="my-1 flex w-full flex-col items-start gap-2">
+      {groups.map((group) => {
+        if (!shouldShowGroupedChain(group)) {
+          return (
+            <div
+              key={group.key}
+              className="flex w-full flex-col items-start gap-2"
+            >
+              {renderToolStepList(group.key, group.items)}
+            </div>
+          );
+        }
+
+        const title = getToolGroupTitle(group.items);
+        const status = getToolGroupStatus(group.items);
+        const stepCount = group.items.length;
+        const headerTitle = formatToolGroupTitle(title, stepCount, status);
+        const open =
+          expandedChainOverrides[group.key] ??
+          group.items.some((item) => {
+            const itemStatus = getToolItemStatus(item);
+            return itemStatus === "pending" || itemStatus === "executing";
+          });
+
+        return (
+          <Tool
+            key={group.key}
+            open={open}
+            onOpenChange={(nextOpen) =>
+              handleChainOpenChange(group.key, nextOpen)
+            }
+            className="inline-flex w-auto max-w-full flex-col"
           >
-            <ChevronRight
-              className={cn(
-                "h-3 w-3 transition-transform",
-                showInternalSteps && "rotate-90",
-              )}
+            <ToolHeader
+              type="dynamic-tool"
+              toolName={title}
+              title={headerTitle}
+              state={toolStatusMap[status]}
+              showIcon={false}
+              layout="fit"
             />
-            {showInternalSteps
-              ? `Hide internal steps (${hiddenItems.length})`
-              : `Show internal steps (${hiddenItems.length})`}
-          </button>
-
-          {showInternalSteps && hiddenItems.map((item) => renderToolItem(item))}
-        </div>
-      )}
+            <ToolContent className="space-y-2">
+              <div className="flex flex-col items-start gap-2">
+                {renderToolStepList(group.key, group.items)}
+              </div>
+            </ToolContent>
+          </Tool>
+        );
+      })}
     </div>
   );
 }
diff --git a/ui/goose2/src/features/chat/ui/__tests__/MessageBubble.test.tsx b/ui/goose2/src/features/chat/ui/__tests__/MessageBubble.test.tsx
index 5f2dff79fc4e..55a00c4f5448 100644
--- a/ui/goose2/src/features/chat/ui/__tests__/MessageBubble.test.tsx
+++ b/ui/goose2/src/features/chat/ui/__tests__/MessageBubble.test.tsx
@@ -1,11 +1,10 @@
-import { afterEach, beforeEach, describe, it, expect, vi } from "vitest";
-import { act, fireEvent, render, screen } from "@testing-library/react";
+import { beforeEach, describe, it, expect, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { MessageBubble } from "../MessageBubble";
 import { useAgentStore } from "@/features/agents/stores/agentStore";
 import type { Message } from "@/shared/types/messages";
 import { openPath } from "@tauri-apps/plugin-opener";
-const mockWriteText = vi.fn().mockResolvedValue(undefined);
 vi.mock("@tauri-apps/plugin-opener", () => ({
   openPath: vi.fn(),
 }));
@@ -37,17 +36,6 @@ describe("MessageBubble", () => {
   beforeEach(() => {
     useAgentStore.setState({ personas: [] });
     vi.mocked(openPath).mockClear();
-    mockWriteText.mockClear();
-    Object.defineProperty(navigator, "clipboard", {
-      configurable: true,
-      value: {
-        writeText: mockWriteText,
-      },
-    });
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
   });
 
   it("renders user message with correct alignment", () => {
@@ -77,6 +65,44 @@ describe("MessageBubble", () => {
     expect(screen.getByText("hello world")).toBeInTheDocument();
   });
 
+  it("hides assistant-only blocks from user messages", () => {
+    render(
+      <MessageBubble
+        message={userMessage("Visible prompt", {
+          content: [
+            {
+              type: "text",
+              text: "Internal prompt",
+              annotations: { audience: ["assistant"] },
+            },
+            { type: "text", text: "Visible prompt" },
+          ],
+        })}
+      />,
+    );
+
+    expect(screen.queryByText("Internal prompt")).not.toBeInTheDocument();
+    expect(screen.getByText("Visible prompt")).toBeInTheDocument();
+  });
+
+  it("hides assistant-only blocks from assistant messages", () => {
+    render(
+      <MessageBubble
+        message={assistantMessage([
+          {
+            type: "text",
+            text: "Internal note",
+            annotations: { audience: ["assistant"] },
+          },
+          { type: "text", text: "Visible reply" },
+        ])}
+      />,
+    );
+
+    expect(screen.queryByText("Internal note")).not.toBeInTheDocument();
+    expect(screen.getByText("Visible reply")).toBeInTheDocument();
+  });
+
   it("renders compaction notifications as centered success messages", () => {
     const { container } = render(
       <MessageBubble
@@ -125,107 +151,6 @@ describe("MessageBubble", () => {
     expect(screen.getByText("second block")).toBeInTheDocument();
   });
 
-  it("renders a reserved actions tray for assistant messages", () => {
-    const onRetryMessage = vi.fn();
-    const { container } = render(
-      <MessageBubble
-        message={assistantMessage([{ type: "text", text: "response" }])}
-        onRetryMessage={onRetryMessage}
-      />,
-    );
-
-    expect(
-      container.querySelector('[data-role="assistant-message"] .pb-8'),
-    ).toBeInTheDocument();
-    expect(
-      container.querySelector(
-        '[data-role="assistant-message"] [data-role="message-actions"]',
-      ),
-    ).toBeInTheDocument();
-    expect(screen.getByRole("button", { name: /retry/i })).toBeInTheDocument();
-  });
-
-  it("keeps the action tray timestamp on one line", () => {
-    const { container } = render(
-      <MessageBubble
-        message={assistantMessage([{ type: "text", text: "response" }])}
-      />,
-    );
-
-    const timestamp = container.querySelector(
-      '[data-role="assistant-message"] [data-role="message-timestamp"]',
-    );
-    expect(timestamp).toHaveClass("whitespace-nowrap");
-    expect(timestamp).toHaveClass("shrink-0");
-  });
-
-  it("anchors assistant and user actions on opposite sides of the timestamp", () => {
-    const { container } = render(
-      <>
-        <MessageBubble
-          message={assistantMessage([{ type: "text", text: "response" }])}
-          onRetryMessage={vi.fn()}
-        />
-        <MessageBubble message={userMessage("draft")} onEditMessage={vi.fn()} />
-      </>,
-    );
-
-    const assistantActions = container.querySelector(
-      '[data-role="assistant-message"] [data-role="message-actions"]',
-    );
-    const userActions = container.querySelector(
-      '[data-role="user-message"] [data-role="message-actions"]',
-    );
-
-    expect(
-      Array.from(assistantActions?.firstElementChild?.children ?? []).map(
-        (element) => element.tagName,
-      ),
-    ).toEqual(["BUTTON", "BUTTON", "SPAN"]);
-    expect(
-      Array.from(userActions?.firstElementChild?.children ?? []).map(
-        (element) => element.tagName,
-      ),
-    ).toEqual(["SPAN", "BUTTON", "BUTTON"]);
-  });
-
-  it("keeps copy confirmation visible until it resets", async () => {
-    vi.useFakeTimers();
-    const { container } = render(
-      <MessageBubble
-        message={assistantMessage([{ type: "text", text: "response" }])}
-      />,
-    );
-
-    const actions = container.querySelector(
-      '[data-role="assistant-message"] [data-role="message-actions"]',
-    );
-    expect(actions).toHaveAttribute("data-copy-confirmed", "false");
-    const copyButton = screen.getByRole("button", { name: /copy/i });
-    expect(copyButton).not.toHaveClass("bg-accent");
-
-    await act(async () => {
-      fireEvent.click(copyButton);
-      await Promise.resolve();
-    });
-
-    expect(mockWriteText).toHaveBeenCalledWith("response");
-    expect(actions).toHaveAttribute("data-copy-confirmed", "true");
-    expect(copyButton).toHaveClass("bg-accent");
-
-    await act(async () => {
-      vi.advanceTimersByTime(1999);
-    });
-    expect(actions).toHaveAttribute("data-copy-confirmed", "true");
-    expect(copyButton).toHaveClass("bg-accent");
-
-    await act(async () => {
-      vi.advanceTimersByTime(1);
-    });
-    expect(actions).toHaveAttribute("data-copy-confirmed", "false");
-    expect(copyButton).not.toHaveClass("bg-accent");
-  });
-
   it("renders tool request content as ToolCallCard", () => {
     const msg = assistantMessage([
       {
@@ -430,10 +355,10 @@ describe("MessageBubble", () => {
     expect(screen.getByTitle("Claude")).toBeInTheDocument();
   });
 
-  it("renders identity for an in-progress assistant message with a provider", () => {
+  it("renders identity for an in-progress assistant message with visible content and a provider", () => {
     render(
       <MessageBubble
-        message={assistantMessage([], {
+        message={assistantMessage([{ type: "text", text: "Working..." }], {
           metadata: { completionStatus: "inProgress", providerId: "codex-acp" },
         })}
         isStreaming
diff --git a/ui/goose2/src/features/chat/ui/__tests__/MessageBubbleActions.test.tsx b/ui/goose2/src/features/chat/ui/__tests__/MessageBubbleActions.test.tsx
new file mode 100644
index 000000000000..205f25e01814
--- /dev/null
+++ b/ui/goose2/src/features/chat/ui/__tests__/MessageBubbleActions.test.tsx
@@ -0,0 +1,188 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { MessageBubble } from "../MessageBubble";
+import { useAgentStore } from "@/features/agents/stores/agentStore";
+import type { Message } from "@/shared/types/messages";
+
+const mockWriteText = vi.fn().mockResolvedValue(undefined);
+
+function userMessage(text: string, overrides: Partial<Message> = {}): Message {
+  return {
+    id: "u1",
+    role: "user",
+    created: Date.now(),
+    content: [{ type: "text", text }],
+    ...overrides,
+  };
+}
+
+function assistantMessage(
+  content: Message["content"],
+  overrides: Partial<Message> = {},
+): Message {
+  return {
+    id: "a1",
+    role: "assistant",
+    created: Date.now(),
+    content,
+    ...overrides,
+  };
+}
+
+describe("MessageBubble actions", () => {
+  beforeEach(() => {
+    useAgentStore.setState({ personas: [] });
+    mockWriteText.mockClear();
+    Object.defineProperty(navigator, "clipboard", {
+      configurable: true,
+      value: {
+        writeText: mockWriteText,
+      },
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("renders a reserved actions tray for pure assistant text messages", () => {
+    const onRetryMessage = vi.fn();
+    const { container } = render(
+      <MessageBubble
+        message={assistantMessage([{ type: "text", text: "response" }])}
+        onRetryMessage={onRetryMessage}
+      />,
+    );
+
+    expect(
+      container.querySelector('[data-role="assistant-message"] .pb-8'),
+    ).toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-role="assistant-message"] [data-role="message-actions"]',
+      ),
+    ).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: /retry/i })).toBeInTheDocument();
+  });
+
+  it("hides the assistant actions tray when tool content is present", () => {
+    const { container } = render(
+      <MessageBubble
+        message={assistantMessage([
+          { type: "text", text: "Checking that now." },
+          {
+            type: "toolRequest",
+            id: "tool-1",
+            name: "readFile",
+            arguments: { path: "/tmp/demo.txt" },
+            status: "completed",
+          },
+          {
+            type: "toolResponse",
+            id: "tool-1",
+            name: "readFile",
+            result: "done",
+            isError: false,
+          },
+        ])}
+        onRetryMessage={vi.fn()}
+      />,
+    );
+
+    expect(
+      container.querySelector('[data-role="assistant-message"] .pb-8'),
+    ).not.toBeInTheDocument();
+    expect(
+      container.querySelector(
+        '[data-role="assistant-message"] [data-role="message-actions"]',
+      ),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: /copy/i }),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: /retry/i }),
+    ).not.toBeInTheDocument();
+  });
+
+  it("keeps the action tray timestamp on one line", () => {
+    const { container } = render(
+      <MessageBubble
+        message={assistantMessage([{ type: "text", text: "response" }])}
+      />,
+    );
+
+    const timestamp = container.querySelector(
+      '[data-role="assistant-message"] [data-role="message-timestamp"]',
+    );
+    expect(timestamp).toHaveClass("whitespace-nowrap");
+    expect(timestamp).toHaveClass("shrink-0");
+  });
+
+  it("anchors assistant and user actions on opposite sides of the timestamp", () => {
+    const { container } = render(
+      <>
+        <MessageBubble
+          message={assistantMessage([{ type: "text", text: "response" }])}
+          onRetryMessage={vi.fn()}
+        />
+        <MessageBubble message={userMessage("draft")} onEditMessage={vi.fn()} />
+      </>,
+    );
+
+    const assistantActions = container.querySelector(
+      '[data-role="assistant-message"] [data-role="message-actions"]',
+    );
+    const userActions = container.querySelector(
+      '[data-role="user-message"] [data-role="message-actions"]',
+    );
+
+    expect(
+      Array.from(assistantActions?.firstElementChild?.children ?? []).map(
+        (element) => element.tagName,
+      ),
+    ).toEqual(["BUTTON", "BUTTON", "SPAN"]);
+    expect(
+      Array.from(userActions?.firstElementChild?.children ?? []).map(
+        (element) => element.tagName,
+      ),
+    ).toEqual(["SPAN", "BUTTON", "BUTTON"]);
+  });
+
+  it("keeps copy confirmation visible until it resets", async () => {
+    vi.useFakeTimers();
+    const { container } = render(
+      <MessageBubble
+        message={assistantMessage([{ type: "text", text: "response" }])}
+      />,
+    );
+
+    const actions = container.querySelector(
+      '[data-role="assistant-message"] [data-role="message-actions"]',
+    );
+    expect(actions).toHaveAttribute("data-copy-confirmed", "false");
+    const copyButton = screen.getByRole("button", { name: /copy/i });
+    expect(copyButton).not.toHaveClass("bg-accent");
+
+    await act(async () => {
+      fireEvent.click(copyButton);
+      await Promise.resolve();
+    });
+
+    expect(mockWriteText).toHaveBeenCalledWith("response");
+    expect(actions).toHaveAttribute("data-copy-confirmed", "true");
+    expect(copyButton).toHaveClass("bg-accent");
+
+    await act(async () => {
+      vi.advanceTimersByTime(1999);
+    });
+    expect(actions).toHaveAttribute("data-copy-confirmed", "true");
+    expect(copyButton).toHaveClass("bg-accent");
+
+    await act(async () => {
+      vi.advanceTimersByTime(1);
+    });
+    expect(actions).toHaveAttribute("data-copy-confirmed", "false");
+    expect(copyButton).not.toHaveClass("bg-accent");
+  });
+});
diff --git a/ui/goose2/src/features/chat/ui/__tests__/MessageBubbleToolChains.test.tsx b/ui/goose2/src/features/chat/ui/__tests__/MessageBubbleToolChains.test.tsx
new file mode 100644
index 000000000000..c3d848a12945
--- /dev/null
+++ b/ui/goose2/src/features/chat/ui/__tests__/MessageBubbleToolChains.test.tsx
@@ -0,0 +1,208 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { describe, expect, it } from "vitest";
+import { MessageBubble } from "../MessageBubble";
+import type { Message } from "@/shared/types/messages";
+
+function assistantMessage(
+  content: Message["content"],
+  overrides: Partial<Message> = {},
+): Message {
+  return {
+    id: "a1",
+    role: "assistant",
+    created: Date.now(),
+    content,
+    ...overrides,
+  };
+}
+
+describe("MessageBubble tool chains", () => {
+  it("groups multi-step ACP tool chains behind a parent card", async () => {
+    const user = userEvent.setup();
+    const msg = assistantMessage([
+      {
+        type: "toolRequest",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "python3 create_whales.py",
+        arguments: {},
+        status: "completed",
+      },
+      {
+        type: "toolResponse",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "python3 create_whales.py",
+        result: "generated draft",
+        isError: false,
+      },
+      {
+        type: "toolRequest",
+        id: "tool-2",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "Create PDF about whales",
+        arguments: {},
+        status: "completed",
+      },
+      {
+        type: "toolResponse",
+        id: "tool-2",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "Create PDF about whales",
+        result: "saved whales.pdf",
+        isError: false,
+      },
+      {
+        type: "toolRequest",
+        id: "tool-3",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "ls -lh whales.pdf",
+        arguments: {},
+        status: "completed",
+      },
+      {
+        type: "toolResponse",
+        id: "tool-3",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "ls -lh whales.pdf",
+        result: "12K whales.pdf",
+        isError: false,
+      },
+      {
+        type: "toolRequest",
+        id: "tool-4",
+        chainId: "chain-1",
+        chainSummary: "reviewing files",
+        name: "Write whales.pdf",
+        arguments: {},
+        status: "completed",
+      },
+      {
+        type: "toolResponse",
+        id: "tool-4",
+        chainId: "chain-1",
+        chainSummary: "reviewing files",
+        name: "Write whales.pdf",
+        result: "done",
+        isError: false,
+      },
+    ]);
+
+    render(<MessageBubble message={msg} />);
+
+    expect(screen.getByText("reviewing files (4 steps)")).toBeInTheDocument();
+    expect(
+      screen.queryByText("python3 create_whales.py"),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText("Write whales.pdf")).not.toBeInTheDocument();
+
+    await user.click(screen.getByText("reviewing files (4 steps)"));
+
+    expect(screen.getByText("Create PDF about whales")).toBeInTheDocument();
+    expect(screen.getByText("Write whales.pdf")).toBeInTheDocument();
+    expect(
+      screen.queryByText("python3 create_whales.py"),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText("ls -lh whales.pdf")).not.toBeInTheDocument();
+    expect(screen.getByText("Show internal steps (2)")).toBeInTheDocument();
+
+    await user.click(screen.getByText("Show internal steps (2)"));
+
+    expect(screen.getByText("python3 create_whales.py")).toBeInTheDocument();
+    expect(screen.getByText("ls -lh whales.pdf")).toBeInTheDocument();
+  });
+
+  it("wraps a single ACP tool call in a parent chain and collapses it when complete", async () => {
+    const user = userEvent.setup();
+    const runningMessage = assistantMessage([
+      {
+        type: "toolRequest",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "Read main.js",
+        arguments: {},
+        status: "executing",
+      },
+    ]);
+
+    const { rerender } = render(<MessageBubble message={runningMessage} />);
+
+    expect(screen.getByText("working through 1 step")).toBeInTheDocument();
+    expect(screen.getByText("Read main.js")).toBeInTheDocument();
+
+    const completedMessage = assistantMessage([
+      {
+        type: "toolRequest",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "reviewing files",
+        name: "Read main.js",
+        arguments: {},
+        status: "completed",
+      },
+      {
+        type: "toolResponse",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "reviewing files",
+        name: "Read main.js",
+        result: "done",
+        isError: false,
+      },
+    ]);
+
+    rerender(<MessageBubble message={completedMessage} />);
+
+    expect(screen.getByText("reviewing files (1 step)")).toBeInTheDocument();
+    expect(screen.queryByText("Read main.js")).not.toBeInTheDocument();
+
+    await user.click(screen.getByText("reviewing files (1 step)"));
+
+    expect(screen.getByText("Read main.js")).toBeInTheDocument();
+  });
+
+  it("shows a failed grouped chain even when another step is still pending", () => {
+    const msg = assistantMessage([
+      {
+        type: "toolRequest",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "Edit main.swift",
+        arguments: {},
+        status: "completed",
+      },
+      {
+        type: "toolResponse",
+        id: "tool-1",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "Edit main.swift",
+        result: "permission denied",
+        isError: true,
+      },
+      {
+        type: "toolRequest",
+        id: "tool-2",
+        chainId: "chain-1",
+        chainSummary: "working",
+        name: "Edit README.md",
+        arguments: {},
+        status: "pending",
+      },
+    ]);
+
+    render(<MessageBubble message={msg} />);
+
+    expect(screen.getByText("working through 2 steps")).toBeInTheDocument();
+    expect(screen.getByText("Error")).toBeInTheDocument();
+  });
+});
diff --git a/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.header-file.test.tsx b/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.header-file.test.tsx
new file mode 100644
index 000000000000..aeed075b5441
--- /dev/null
+++ b/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.header-file.test.tsx
@@ -0,0 +1,146 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ToolCardDisplay } from "@/features/chat/hooks/ArtifactPolicyContext";
+import type { ArtifactPathCandidate } from "@/features/chat/lib/artifactPathPolicy";
+import { ToolCallAdapter } from "../ToolCallAdapter";
+
+const mockResolveToolCardDisplay =
+  vi.fn<
+    (
+      args: Record<string, unknown>,
+      name: string,
+      result?: string,
+    ) => ToolCardDisplay
+  >();
+const mockResolveMarkdownHref =
+  vi.fn<(href: string) => ArtifactPathCandidate | null>();
+const mockPathExists = vi.fn<(path: string) => Promise<boolean>>();
+const mockOpenResolvedPath = vi.fn<(path: string) => Promise<void>>();
+
+vi.mock("@/features/chat/hooks/ArtifactPolicyContext", () => ({
+  useArtifactPolicyContext: () => ({
+    resolveToolCardDisplay: mockResolveToolCardDisplay,
+    resolveMarkdownHref: mockResolveMarkdownHref,
+    pathExists: mockPathExists,
+    openResolvedPath: mockOpenResolvedPath,
+  }),
+}));
+
+const EMPTY_DISPLAY: ToolCardDisplay = {
+  role: "none",
+  primaryCandidate: null,
+  secondaryCandidates: [],
+};
+
+function makeCandidate(
+  overrides: Partial<ArtifactPathCandidate> = {},
+): ArtifactPathCandidate {
+  return {
+    id: "c-1",
+    rawPath: "/project/Sources/main.swift",
+    resolvedPath: "/project/Sources/main.swift",
+    source: "arg_key",
+    confidence: "high",
+    kind: "file",
+    allowed: true,
+    blockedReason: null,
+    toolCallId: "tool-1",
+    toolName: "edit_file",
+    toolCallIndex: 0,
+    appearanceIndex: 0,
+    ...overrides,
+  };
+}
+
+function renderAdapter(
+  overrides: Partial<Parameters<typeof ToolCallAdapter>[0]> = {},
+) {
+  return render(
+    <ToolCallAdapter
+      name="Edit main.swift"
+      arguments={{ path: "/project/Sources/main.swift", line: 1 }}
+      kind="edit"
+      status="completed"
+      result="Updated /project/Sources/main.swift"
+      open={undefined}
+      {...overrides}
+    />,
+  );
+}
+
+beforeEach(() => {
+  mockResolveToolCardDisplay.mockReset();
+  mockResolveToolCardDisplay.mockReturnValue(EMPTY_DISPLAY);
+  mockResolveMarkdownHref.mockReset();
+  mockResolveMarkdownHref.mockImplementation((href) =>
+    makeCandidate({
+      rawPath: href,
+      resolvedPath: href,
+    }),
+  );
+  mockPathExists.mockReset();
+  mockPathExists.mockResolvedValue(true);
+  mockOpenResolvedPath.mockReset();
+  mockOpenResolvedPath.mockResolvedValue(undefined);
+});
+
+describe("ToolCallAdapter header file link", () => {
+  it("opens the file from the header filename without expanding the accordion", async () => {
+    const user = userEvent.setup();
+
+    renderAdapter();
+
+    await user.click(screen.getByRole("button", { name: /open main\.swift/i }));
+
+    expect(mockOpenResolvedPath).toHaveBeenCalledWith(
+      "/project/Sources/main.swift",
+    );
+    expect(screen.queryByText("Path")).not.toBeInTheDocument();
+  });
+
+  it("does not expose a clickable header filename outside allowed roots", async () => {
+    const user = userEvent.setup();
+    mockResolveMarkdownHref.mockReturnValue(
+      makeCandidate({
+        rawPath: "/etc/passwd",
+        resolvedPath: "/etc/passwd",
+        allowed: false,
+        blockedReason: "Path is outside allowed project/artifacts roots.",
+      }),
+    );
+
+    renderAdapter({
+      name: "Edit passwd",
+      arguments: { path: "/etc/passwd", line: 1 },
+      result: "Updated /etc/passwd",
+    });
+
+    expect(
+      screen.queryByRole("button", { name: /open passwd/i }),
+    ).not.toBeInTheDocument();
+
+    await user.click(screen.getByText("passwd"));
+
+    expect(mockOpenResolvedPath).not.toHaveBeenCalled();
+    expect(screen.getByText("Path")).toBeInTheDocument();
+  });
+
+  it("opens the accordion when clicking the non-file title text", async () => {
+    const user = userEvent.setup();
+
+    const { container } = renderAdapter();
+
+    const titlePrefix = container.querySelector("[data-tool-title-prefix]");
+    expect(titlePrefix).toBeTruthy();
+
+    if (!titlePrefix) {
+      throw new Error("Expected non-file title text");
+    }
+
+    await user.click(titlePrefix);
+
+    expect(mockOpenResolvedPath).not.toHaveBeenCalled();
+    expect(screen.getByText("Path")).toBeInTheDocument();
+  });
+});
diff --git a/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.test.tsx b/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.test.tsx
index 690db965a69a..7565ea58e3f2 100644
--- a/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.test.tsx
+++ b/ui/goose2/src/features/chat/ui/__tests__/ToolCallAdapter.test.tsx
@@ -1,6 +1,6 @@
-import { render, screen } from "@testing-library/react";
+import { render, screen, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { ToolCardDisplay } from "@/features/chat/hooks/ArtifactPolicyContext";
 import type { ArtifactPathCandidate } from "@/features/chat/lib/artifactPathPolicy";
 import { ToolCallAdapter } from "../ToolCallAdapter";
@@ -15,13 +15,15 @@ const mockResolveToolCardDisplay =
       result?: string,
     ) => ToolCardDisplay
   >();
+const mockResolveMarkdownHref =
+  vi.fn<(href: string) => ArtifactPathCandidate | null>();
 const mockPathExists = vi.fn<(path: string) => Promise<boolean>>();
 const mockOpenResolvedPath = vi.fn<(path: string) => Promise<void>>();
 
 vi.mock("@/features/chat/hooks/ArtifactPolicyContext", () => ({
   useArtifactPolicyContext: () => ({
     resolveToolCardDisplay: mockResolveToolCardDisplay,
-    resolveMarkdownHref: () => null,
+    resolveMarkdownHref: mockResolveMarkdownHref,
     pathExists: mockPathExists,
     openResolvedPath: mockOpenResolvedPath,
   }),
@@ -55,6 +57,22 @@ function makeCandidate(
   };
 }
 
+beforeEach(() => {
+  mockResolveToolCardDisplay.mockReset();
+  mockResolveToolCardDisplay.mockReturnValue(EMPTY_DISPLAY);
+  mockResolveMarkdownHref.mockReset();
+  mockResolveMarkdownHref.mockImplementation((href) =>
+    makeCandidate({
+      rawPath: href,
+      resolvedPath: href,
+    }),
+  );
+  mockPathExists.mockReset();
+  mockPathExists.mockResolvedValue(true);
+  mockOpenResolvedPath.mockReset();
+  mockOpenResolvedPath.mockResolvedValue(undefined);
+});
+
 function renderAdapter(
   overrides: Partial<Parameters<typeof ToolCallAdapter>[0]> = {},
 ) {
@@ -62,8 +80,10 @@ function renderAdapter(
     <ToolCallAdapter
       name="write_file"
       arguments={{ path: "/project/output.md" }}
+      kind="edit"
       status="completed"
       result="Created /project/output.md"
+      open
       {...overrides}
     />,
   );
@@ -72,6 +92,173 @@ function renderAdapter(
 // ── tests ────────────────────────────────────────────────────────────
 
 describe("ToolCallAdapter — ArtifactActions", () => {
+  it("renders a deterministic input summary and reveals raw input on demand", async () => {
+    const user = userEvent.setup();
+    mockResolveToolCardDisplay.mockReturnValue(EMPTY_DISPLAY);
+
+    renderAdapter({
+      name: "read_file",
+      kind: "read",
+      arguments: { path: "/project/src/main.ts", line: 12 },
+      result: "file contents",
+    });
+
+    expect(screen.getByText("Path")).toBeInTheDocument();
+    expect(screen.getByText("main.ts")).toBeInTheDocument();
+    expect(screen.getByText("Line")).toBeInTheDocument();
+    expect(screen.getByText("12")).toBeInTheDocument();
+    expect(screen.queryByText("/project/src/main.ts")).not.toBeInTheDocument();
+    expect(
+      screen.queryByText('"path": "/project/src/main.ts"'),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText("Parameters")).not.toBeInTheDocument();
+    expect(screen.queryByText("Raw input")).not.toBeInTheDocument();
+
+    const rawInputTrigger = screen.getByText("main.ts").closest("button");
+
+    expect(rawInputTrigger).toBeTruthy();
+
+    if (!rawInputTrigger) {
+      throw new Error("Expected raw input trigger");
+    }
+
+    await user.click(rawInputTrigger);
+
+    const rawInputPanel = rawInputTrigger
+      ?.closest('[data-slot="collapsible"]')
+      ?.querySelector("pre");
+
+    expect(rawInputPanel).toHaveTextContent('"path": "/project/src/main.ts"');
+  });
+
+  it("renders command input summaries with a clamped preview and expanded bash highlighting", async () => {
+    const user = userEvent.setup();
+    mockResolveToolCardDisplay.mockReturnValue(EMPTY_DISPLAY);
+
+    const { container } = renderAdapter({
+      name: "shell",
+      kind: "execute",
+      arguments: {
+        command: "cat /project/package.json",
+        cwd: "/project",
+      },
+      result: "package contents",
+    });
+
+    expect(screen.getByText("Command")).toBeInTheDocument();
+    expect(screen.getByText("cat /project/package.json")).toBeInTheDocument();
+    expect(screen.getByText("Working directory")).toBeInTheDocument();
+    expect(screen.getByText("/project")).toBeInTheDocument();
+    expect(screen.getByText("package contents")).toBeInTheDocument();
+    expect(screen.queryByText("Result")).not.toBeInTheDocument();
+    const commandPreview = container.querySelector(
+      "[data-tool-command-preview]",
+    );
+    expect(commandPreview).toBeTruthy();
+    expect(commandPreview?.className).toContain("[&_pre]:line-clamp-3");
+    expect(container.querySelector('[data-language="bash"]')).toBeTruthy();
+    expect(container.querySelector('[data-language="json"]')).toBeFalsy();
+
+    await user.click(screen.getByText("cat /project/package.json"));
+
+    const commandBlock = container.querySelector('[data-language="bash"]');
+    expect(commandBlock).toBeTruthy();
+    expect(commandBlock).toHaveTextContent("cat /project/package.json");
+    expect(container.querySelector('[data-language="json"]')).toBeFalsy();
+  });
+
+  it("renders single-file responses without a duplicate files section", () => {
+    mockResolveToolCardDisplay.mockReturnValue(EMPTY_DISPLAY);
+
+    const view = renderAdapter({
+      name: "read_file",
+      kind: "read",
+      arguments: { path: "/project/src/renderer.js" },
+      locations: [{ path: "/project/src/renderer.js", line: 42 }],
+      rawOutput: "rendered raw output",
+      result: "flattened result",
+    });
+
+    expect(screen.getByText("Path")).toBeInTheDocument();
+    expect(screen.getByText("renderer.js")).toBeInTheDocument();
+    expect(screen.getByText("Line")).toBeInTheDocument();
+    expect(screen.getByText("42")).toBeInTheDocument();
+    expect(screen.getByText("flattened result")).toBeInTheDocument();
+    expect(screen.queryByText("Result")).not.toBeInTheDocument();
+    expect(screen.queryByText("Raw result")).not.toBeInTheDocument();
+    expect(screen.queryByText("Files")).not.toBeInTheDocument();
+    expect(screen.queryByText("renderer.js:42")).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: /open file/i }),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText(/more outputs/i)).not.toBeInTheDocument();
+    expect(view.container.querySelector('[data-language="json"]')).toBeFalsy();
+  });
+
+  it("renders multi-location fallbacks as inline file pills", async () => {
+    const user = userEvent.setup();
+
+    renderAdapter({
+      name: "read_file",
+      kind: "read",
+      arguments: { path: "/project/src/renderer.js", line: 42 },
+      locations: [
+        { path: "/project/src/renderer.js", line: 42 },
+        { path: "/project/src/index.js", line: 12 },
+      ],
+      result: "flattened result",
+    });
+
+    expect(screen.getByText("Files")).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", { name: /renderer\.js:42/i }),
+    ).toHaveClass("rounded-full");
+    expect(screen.getByRole("button", { name: /index\.js:12/i })).toHaveClass(
+      "rounded-full",
+    );
+    expect(
+      screen.queryByText("/project/src/index.js:12"),
+    ).not.toBeInTheDocument();
+
+    await user.click(screen.getByRole("button", { name: /index\.js:12/i }));
+
+    expect(mockOpenResolvedPath).toHaveBeenCalledWith("/project/src/index.js");
+  });
+
+  it("disables multi-location pills outside allowed roots", () => {
+    mockResolveMarkdownHref.mockImplementation((href) =>
+      href === "/project/src/index.js"
+        ? makeCandidate({
+            rawPath: href,
+            resolvedPath: href,
+            allowed: false,
+            blockedReason: "Path is outside allowed project/artifacts roots.",
+          })
+        : makeCandidate({
+            rawPath: href,
+            resolvedPath: href,
+          }),
+    );
+
+    renderAdapter({
+      name: "read_file",
+      kind: "read",
+      arguments: { path: "/project/src/renderer.js", line: 42 },
+      locations: [
+        { path: "/project/src/renderer.js", line: 42 },
+        { path: "/project/src/index.js", line: 12 },
+      ],
+      result: "flattened result",
+    });
+
+    expect(
+      screen.getByRole("button", { name: /renderer\.js:42/i }),
+    ).toBeEnabled();
+    expect(
+      screen.getByRole("button", { name: /index\.js:12/i }),
+    ).toBeDisabled();
+  });
+
   it('renders "Open file" button when primary candidate exists', () => {
     const primary = makeCandidate();
     mockResolveToolCardDisplay.mockReturnValue({
@@ -82,8 +269,10 @@ describe("ToolCallAdapter — ArtifactActions", () => {
 
     renderAdapter();
 
-    expect(screen.getByRole("button", { name: /open file/i })).toBeEnabled();
-    expect(screen.getByText(primary.rawPath)).toBeInTheDocument();
+    const openFileButton = screen.getByRole("button", { name: /open file/i });
+    expect(openFileButton).toBeEnabled();
+    expect(openFileButton).toHaveTextContent(primary.rawPath ?? "");
+    expect(screen.getByText("output.md")).toBeInTheDocument();
   });
 
   it("does NOT render artifact actions when display role is none", () => {
@@ -116,7 +305,11 @@ describe("ToolCallAdapter — ArtifactActions", () => {
     expect(toggle).toBeInTheDocument();
 
     // Secondary button not visible initially
-    expect(screen.queryByText(secondary.rawPath)).not.toBeInTheDocument();
+    expect(
+      within(toggle.closest("div") ?? document.body).queryByText(
+        secondary.rawPath,
+      ),
+    ).not.toBeInTheDocument();
 
     await user.click(toggle);
 
diff --git a/ui/goose2/src/shared/ui/ai-elements/tool.tsx b/ui/goose2/src/shared/ui/ai-elements/tool.tsx
index 5927bfae99e0..7b8e51b1efb5 100644
--- a/ui/goose2/src/shared/ui/ai-elements/tool.tsx
+++ b/ui/goose2/src/shared/ui/ai-elements/tool.tsx
@@ -1,3 +1,4 @@
+import { useControllableState } from "@radix-ui/react-use-controllable-state";
 import {
   Collapsible,
   CollapsibleContent,
@@ -13,24 +14,65 @@ import {
   WrenchIcon,
   XCircleIcon,
 } from "lucide-react";
+import type { LucideIcon } from "lucide-react";
 import type { ComponentProps, ReactNode } from "react";
-import { isValidElement } from "react";
+import {
+  createContext,
+  isValidElement,
+  useEffect,
+  useContext,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 
 import { CodeBlock } from "./code-block";
 
 export type ToolProps = ComponentProps<typeof Collapsible>;
 
-export const Tool = ({ className, ...props }: ToolProps) => (
-  <Collapsible className={cn("group not-prose w-full", className)} {...props} />
-);
+interface ToolContextValue {
+  isOpen: boolean;
+  setIsOpen: (open: boolean) => void;
+}
+
+const ToolContext = createContext<ToolContextValue | null>(null);
+
+export const Tool = ({
+  className,
+  open,
+  defaultOpen = false,
+  onOpenChange,
+  ...props
+}: ToolProps) => {
+  const [isOpen, setIsOpen] = useControllableState({
+    defaultProp: defaultOpen,
+    onChange: onOpenChange,
+    prop: open,
+  });
+  const value = useMemo(() => ({ isOpen, setIsOpen }), [isOpen, setIsOpen]);
+
+  return (
+    <ToolContext.Provider value={value}>
+      <Collapsible
+        className={cn("group not-prose w-full", className)}
+        open={isOpen}
+        onOpenChange={setIsOpen}
+        {...props}
+      />
+    </ToolContext.Provider>
+  );
+};
 
 export type ToolPart = ToolUIPart | DynamicToolUIPart;
 
 export type ToolHeaderProps = {
-  title?: string;
+  title?: ReactNode;
+  splitTrigger?: boolean;
   className?: string;
   showIcon?: boolean;
+  showStatusBadge?: boolean;
   elapsedSeconds?: number;
+  layout?: "fill" | "fit";
 } & (
   | { type: ToolUIPart["type"]; state: ToolUIPart["state"]; toolName?: never }
   | {
@@ -50,22 +92,61 @@ const statusLabels: Record<ToolPart["state"], string> = {
   "output-error": "Error",
 };
 
-const statusIcons: Record<ToolPart["state"], ReactNode> = {
-  "approval-requested": <ClockIcon className="size-4 text-yellow-600" />,
-  "approval-responded": <CheckCircleIcon className="size-4 text-blue-600" />,
-  "input-available": <ClockIcon className="size-4 animate-pulse" />,
-  "input-streaming": <CircleIcon className="size-4" />,
-  "output-available": <CheckCircleIcon className="size-4 text-green-600" />,
-  "output-denied": <XCircleIcon className="size-4 text-orange-600" />,
-  "output-error": <XCircleIcon className="size-4 text-red-600" />,
+const statusIconComponents: Record<ToolPart["state"], LucideIcon> = {
+  "approval-requested": ClockIcon,
+  "approval-responded": CheckCircleIcon,
+  "input-available": ClockIcon,
+  "input-streaming": CircleIcon,
+  "output-available": CheckCircleIcon,
+  "output-denied": XCircleIcon,
+  "output-error": XCircleIcon,
+};
+
+const statusIconClasses: Record<ToolPart["state"], string> = {
+  "approval-requested": "text-yellow-600",
+  "approval-responded": "text-blue-600",
+  "input-available": "animate-pulse",
+  "input-streaming": "",
+  "output-available": "text-green-600",
+  "output-denied": "text-orange-600",
+  "output-error": "text-red-600",
 };
 
-export const getStatusBadge = (status: ToolPart["state"]) => {
+export const ToolStatusIcon = ({
+  status,
+  className,
+}: {
+  status: ToolPart["state"];
+  className?: string;
+}) => {
+  const Icon = statusIconComponents[status];
+
+  return (
+    <Icon
+      aria-hidden="true"
+      className={cn("size-4 shrink-0", statusIconClasses[status], className)}
+    />
+  );
+};
+
+export const getStatusBadge = (
+  status: ToolPart["state"],
+  className?: string,
+) => {
   if (status === "output-available") return null;
+  const label = statusLabels[status];
+  const isIconOnly = status === "output-error";
+
   return (
-    <span className="flex items-center gap-1 text-xs text-muted-foreground">
-      {statusIcons[status]}
-      {statusLabels[status]}
+    <span
+      className={cn(
+        "shrink-0 flex items-center text-xs text-muted-foreground",
+        !isIconOnly && "gap-1",
+        className,
+      )}
+    >
+      <ToolStatusIcon status={status} />
+      {isIconOnly ? <span className="sr-only">{label}</span> : label}
     </span>
   );
 };
@@ -73,30 +154,176 @@ export const getStatusBadge = (status: ToolPart["state"]) => {
 export const ToolHeader = ({
   className,
   title,
+  splitTrigger = false,
   type,
   state,
   toolName,
   showIcon = true,
+  showStatusBadge = true,
   elapsedSeconds,
+  layout = "fill",
   ...props
 }: ToolHeaderProps) => {
   const derivedName =
     type === "dynamic-tool" ? toolName : type.split("-").slice(1).join("-");
+  const isFitLayout = layout === "fit";
+  const toolContext = useContext(ToolContext);
+  const isOpen = toolContext?.isOpen ?? false;
+  const shouldAnimateErrorBadge = showStatusBadge && state === "output-error";
+  const subtleHoverTextClasses = "group-hover/tool-header:!text-foreground";
+  const titleClasses = cn(
+    "min-w-0 truncate text-left text-[13px] font-normal text-muted-foreground transition-colors",
+    subtleHoverTextClasses,
+    {
+      "flex-none max-w-full": isFitLayout,
+      "flex-1": !isFitLayout,
+    },
+  );
+  const containerClasses = cn(
+    "group/tool-header items-center gap-1.5 py-px",
+    isFitLayout ? "inline-flex w-fit max-w-full self-start" : "flex w-full",
+    className,
+  );
+
+  if (splitTrigger) {
+    return (
+      <div className={containerClasses}>
+        <div
+          className={cn("min-w-0 cursor-pointer items-center gap-1.5", {
+            "flex flex-1": !isFitLayout,
+            "inline-flex max-w-full": isFitLayout,
+          })}
+          role="button"
+          tabIndex={0}
+          onClick={() => toolContext?.setIsOpen(!isOpen)}
+          onKeyDown={(event) => {
+            if (event.key === "Enter" || event.key === " ") {
+              event.preventDefault();
+              toolContext?.setIsOpen(!isOpen);
+            }
+          }}
+        >
+          {showIcon && (
+            <WrenchIcon
+              className={cn(
+                "size-4 shrink-0 text-muted-foreground transition-colors",
+                subtleHoverTextClasses,
+              )}
+            />
+          )}
+          <span className={titleClasses}>{title ?? derivedName}</span>
+        </div>
+        <CollapsibleTrigger className="shrink-0 flex items-center gap-1.5">
+          {showStatusBadge &&
+            !shouldAnimateErrorBadge &&
+            getStatusBadge(
+              state,
+              cn(
+                "text-[11px] text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+                subtleHoverTextClasses,
+              ),
+            )}
+          {shouldAnimateErrorBadge && (
+            <span
+              aria-hidden={isOpen}
+              className={cn(
+                "shrink-0 whitespace-nowrap transition-[opacity,transform,margin] duration-200 ease-out motion-reduce:transition-none",
+                "[button[data-state=open]_&]:pointer-events-none [button[data-state=open]_&]:opacity-0 [button[data-state=open]_&]:-translate-x-2.5 [button[data-state=open]_&]:-mr-[1.375rem]",
+              )}
+            >
+              {getStatusBadge(
+                state,
+                cn(
+                  "text-[11px] text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+                  subtleHoverTextClasses,
+                ),
+              )}
+            </span>
+          )}
+          {elapsedSeconds != null && (
+            <span
+              className={cn(
+                "shrink-0 tabular-nums text-xs text-muted-foreground transition-colors",
+                "text-[11px] text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+                subtleHoverTextClasses,
+              )}
+            >
+              {elapsedSeconds}s
+            </span>
+          )}
+          <span className="shrink-0 flex">
+            <ChevronDownIcon
+              className={cn(
+                "size-3.5 shrink-0 transition-[color,transform] [button[data-state=closed]_&]:-rotate-90",
+                "text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+                subtleHoverTextClasses,
+              )}
+            />
+          </span>
+        </CollapsibleTrigger>
+      </div>
+    );
+  }
 
   return (
-    <CollapsibleTrigger
-      className={cn("inline-flex items-center gap-1.5 py-px", className)}
-      {...props}
-    >
-      {showIcon && <WrenchIcon className="size-4 text-muted-foreground" />}
-      <span className="font-medium text-sm">{title ?? derivedName}</span>
-      {getStatusBadge(state)}
-      {elapsedSeconds != null && (
-        <span className="tabular-nums text-xs text-muted-foreground">
-          {elapsedSeconds}s
-        </span>
+    <CollapsibleTrigger className={containerClasses} {...props}>
+      {showIcon && (
+        <WrenchIcon
+          className={cn(
+            "size-4 shrink-0 text-muted-foreground transition-colors",
+            subtleHoverTextClasses,
+          )}
+        />
       )}
-      <ChevronDownIcon className="size-3.5 text-muted-foreground transition-transform group-data-[state=closed]:-rotate-90" />
+      <span className={titleClasses}>{title ?? derivedName}</span>
+      <span className="shrink-0 flex items-center gap-1.5">
+        {showStatusBadge &&
+          !shouldAnimateErrorBadge &&
+          getStatusBadge(
+            state,
+            cn(
+              "text-[11px] text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+              subtleHoverTextClasses,
+            ),
+          )}
+        {shouldAnimateErrorBadge && (
+          <span
+            aria-hidden={isOpen}
+            className={cn(
+              "shrink-0 whitespace-nowrap transition-[opacity,transform,margin] duration-200 ease-out motion-reduce:transition-none",
+              "[button[data-state=open]_&]:pointer-events-none [button[data-state=open]_&]:opacity-0 [button[data-state=open]_&]:-translate-x-2.5 [button[data-state=open]_&]:-mr-[1.375rem]",
+            )}
+          >
+            {getStatusBadge(
+              state,
+              cn(
+                "text-[11px] text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+                subtleHoverTextClasses,
+              ),
+            )}
+          </span>
+        )}
+        {elapsedSeconds != null && (
+          <span
+            className={cn(
+              "shrink-0 tabular-nums text-xs text-muted-foreground transition-colors",
+              "text-[11px] text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+              subtleHoverTextClasses,
+            )}
+          >
+            {elapsedSeconds}s
+          </span>
+        )}
+        <span className="shrink-0 flex">
+          <ChevronDownIcon
+            className={cn(
+              "size-3.5 shrink-0 transition-[color,transform] [button[data-state=closed]_&]:-rotate-90",
+              "text-muted-foreground/80 [button[data-state=open]_&]:text-muted-foreground",
+              subtleHoverTextClasses,
+            )}
+          />
+        </span>
+      </span>
     </CollapsibleTrigger>
   );
 };
@@ -113,30 +340,227 @@ export const ToolContent = ({ className, ...props }: ToolContentProps) => (
   />
 );
 
-export type ToolInputProps = ComponentProps<"div"> & {
-  input: ToolPart["input"];
+export type ToolSectionProps = ComponentProps<"div"> & {
+  label: string;
 };
 
-export const ToolInput = ({ className, input, ...props }: ToolInputProps) => (
-  <div className={cn("space-y-2 overflow-hidden", className)} {...props}>
+export const ToolSection = ({
+  className,
+  label,
+  children,
+  ...props
+}: ToolSectionProps) => (
+  <div className={cn("space-y-2", className)} {...props}>
     <h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
-      Parameters
+      {label}
     </h4>
-    <div className="rounded-md bg-muted/50">
-      <CodeBlock code={JSON.stringify(input, null, 2)} language="json" />
-    </div>
+    {children}
   </div>
 );
 
+export type ToolSurfaceProps = ComponentProps<"div"> & {
+  destructive?: boolean;
+  tone?: "muted" | "outline";
+};
+
+export const ToolSurface = ({
+  className,
+  destructive = false,
+  tone = "muted",
+  ...props
+}: ToolSurfaceProps) => (
+  <div
+    className={cn(
+      "overflow-x-auto rounded-md text-xs [&_code]:font-mono [&_pre]:whitespace-pre-wrap [&_pre]:break-words",
+      destructive
+        ? "bg-destructive/10 text-destructive"
+        : tone === "outline"
+          ? "border border-border bg-background text-foreground"
+          : "bg-muted/50 text-foreground",
+      className,
+    )}
+    {...props}
+  />
+);
+
+function EmbeddedOverflowViewport({
+  className,
+  children,
+}: {
+  className?: string;
+  children: ReactNode;
+}) {
+  const viewportRef = useRef<HTMLDivElement>(null);
+  const contentRef = useRef<HTMLDivElement>(null);
+  const [showTopFade, setShowTopFade] = useState(false);
+  const [showBottomFade, setShowBottomFade] = useState(false);
+
+  useEffect(() => {
+    const viewport = viewportRef.current;
+    if (!viewport) {
+      return;
+    }
+
+    const updateFadeState = () => {
+      const { scrollTop, scrollHeight, clientHeight } = viewport;
+      const hasOverflow = scrollHeight - clientHeight > 1;
+
+      setShowTopFade(hasOverflow && scrollTop > 1);
+      setShowBottomFade(
+        hasOverflow && scrollTop + clientHeight < scrollHeight - 1,
+      );
+    };
+
+    updateFadeState();
+
+    viewport.addEventListener("scroll", updateFadeState, { passive: true });
+    window.addEventListener("resize", updateFadeState);
+
+    let resizeObserver: ResizeObserver | undefined;
+    if (typeof ResizeObserver !== "undefined") {
+      resizeObserver = new ResizeObserver(() => updateFadeState());
+      resizeObserver.observe(viewport);
+
+      if (contentRef.current) {
+        resizeObserver.observe(contentRef.current);
+      }
+    }
+
+    return () => {
+      viewport.removeEventListener("scroll", updateFadeState);
+      window.removeEventListener("resize", updateFadeState);
+      resizeObserver?.disconnect();
+    };
+  }, [children]);
+
+  return (
+    <div className="relative">
+      <div ref={viewportRef} className={className}>
+        <div ref={contentRef}>{children}</div>
+      </div>
+      {showTopFade ? (
+        <div className="pointer-events-none absolute inset-x-0 top-0 z-10 h-8 bg-gradient-to-b from-muted to-transparent" />
+      ) : null}
+      {showBottomFade ? (
+        <div className="pointer-events-none absolute inset-x-0 bottom-0 z-10 h-8 bg-gradient-to-t from-muted to-transparent" />
+      ) : null}
+    </div>
+  );
+}
+
+export type ToolInputProps = ComponentProps<"div"> & {
+  input: ToolPart["input"];
+  label?: string;
+  showLabel?: boolean;
+  summary?: ReactNode | ((options: { isOpen: boolean }) => ReactNode);
+  embedded?: boolean;
+};
+
+export const ToolInput = ({
+  className,
+  input,
+  label = "Input",
+  showLabel = true,
+  summary,
+  embedded = false,
+  ...props
+}: ToolInputProps) => {
+  const [isInputOpen, setIsInputOpen] = useState(false);
+  const hasStructuredInput =
+    input !== undefined &&
+    input !== null &&
+    (typeof input !== "object" ||
+      Array.isArray(input) ||
+      Object.keys(input as Record<string, unknown>).length > 0);
+
+  if (!summary && !hasStructuredInput) {
+    return null;
+  }
+
+  const summaryContent =
+    typeof summary === "function" ? (
+      summary({ isOpen: isInputOpen })
+    ) : summary ? (
+      summary
+    ) : (
+      <span className="text-xs text-muted-foreground">{label}</span>
+    );
+
+  const inputBody = hasStructuredInput ? (
+    <Collapsible open={isInputOpen} onOpenChange={setIsInputOpen}>
+      <CollapsibleTrigger asChild>
+        <button
+          type="button"
+          className="flex w-full items-start gap-3 text-left"
+        >
+          <div className="min-w-0 flex-1">{summaryContent}</div>
+          <ChevronDownIcon className="mt-0.5 size-3.5 shrink-0 text-muted-foreground transition-transform [button[data-state=closed]_&]:-rotate-90" />
+        </button>
+      </CollapsibleTrigger>
+      <CollapsibleContent className="data-[state=closed]:fade-out-0 data-[state=closed]:slide-out-to-top-1 data-[state=open]:slide-in-from-top-1 mt-2 overflow-hidden outline-none data-[state=closed]:animate-out data-[state=open]:animate-in">
+        <pre className="overflow-auto whitespace-pre-wrap break-words font-mono text-[12px] leading-5 text-foreground/90">
+          {JSON.stringify(input, null, 2)}
+        </pre>
+      </CollapsibleContent>
+    </Collapsible>
+  ) : (
+    summaryContent
+  );
+
+  const content = embedded ? (
+    <div className="px-3 py-2">{inputBody}</div>
+  ) : hasStructuredInput ? (
+    <ToolSurface tone="muted" className="px-3 py-2">
+      {inputBody}
+    </ToolSurface>
+  ) : (
+    <ToolSurface tone="muted" className="px-3 py-2">
+      {summaryContent}
+    </ToolSurface>
+  );
+
+  if (!showLabel) {
+    return (
+      <div
+        className={cn(
+          embedded ? "overflow-hidden" : "space-y-2 overflow-hidden",
+          className,
+        )}
+        {...props}
+      >
+        {content}
+      </div>
+    );
+  }
+
+  return (
+    <ToolSection
+      label={label}
+      className={cn("overflow-hidden", className)}
+      {...props}
+    >
+      {content}
+    </ToolSection>
+  );
+};
+
 export type ToolOutputProps = ComponentProps<"div"> & {
   output: ToolPart["output"];
   errorText: ToolPart["errorText"];
+  label?: string;
+  showLabel?: boolean;
+  tone?: ToolSurfaceProps["tone"];
+  embedded?: boolean;
 };
 
 export const ToolOutput = ({
   className,
   output,
   errorText,
+  label,
+  showLabel = true,
+  tone = "muted",
+  embedded = false,
   ...props
 }: ToolOutputProps) => {
   if (!(output || errorText)) {
@@ -145,30 +569,96 @@ export const ToolOutput = ({
 
   let Output = <div>{output as ReactNode}</div>;
 
+  const outputCodeBlockClassName = cn(
+    "[&_pre]:text-[12px] [&_pre]:leading-5 [&_code]:text-[12px] [&_code]:leading-5",
+    embedded &&
+      "rounded-none border-0 bg-transparent shadow-none [&_pre]:m-0 [&_pre]:bg-transparent [&_pre]:p-0",
+  );
+
   if (typeof output === "object" && !isValidElement(output)) {
     Output = (
-      <CodeBlock code={JSON.stringify(output, null, 2)} language="json" />
+      <CodeBlock
+        code={JSON.stringify(output, null, 2)}
+        language="json"
+        className={outputCodeBlockClassName}
+      />
     );
   } else if (typeof output === "string") {
-    Output = <CodeBlock code={output} language="json" />;
+    Output = (
+      <CodeBlock
+        code={output}
+        language="json"
+        className={outputCodeBlockClassName}
+      />
+    );
   }
 
-  return (
-    <div className={cn("space-y-2", className)} {...props}>
-      <h4 className="font-medium text-muted-foreground text-xs uppercase tracking-wide">
-        {errorText ? "Error" : "Result"}
-      </h4>
-      <div
-        className={cn(
-          "overflow-x-auto rounded-md text-xs [&_table]:w-full [&_pre]:whitespace-pre-wrap [&_pre]:break-words",
-          errorText
-            ? "bg-destructive/10 text-destructive"
-            : "bg-muted/50 text-foreground",
+  if (embedded) {
+    const plainTextClasses =
+      "m-0 whitespace-pre-wrap break-words font-mono text-[12px] leading-5";
+
+    const plainOutput = errorText
+      ? errorText
+      : typeof output === "string"
+        ? output
+        : typeof output === "object" && !isValidElement(output)
+          ? JSON.stringify(output, null, 2)
+          : null;
+
+    return (
+      <div className={cn("overflow-hidden px-3 pb-2", className)} {...props}>
+        {plainOutput != null ? (
+          <EmbeddedOverflowViewport className="max-h-16 overflow-auto">
+            <pre
+              className={cn(
+                plainTextClasses,
+                errorText ? "text-destructive" : "text-muted-foreground",
+              )}
+            >
+              {plainOutput}
+            </pre>
+          </EmbeddedOverflowViewport>
+        ) : (
+          <EmbeddedOverflowViewport className="max-h-16 overflow-auto text-muted-foreground">
+            {Output}
+          </EmbeddedOverflowViewport>
+        )}
+      </div>
+    );
+  }
+
+  if (!showLabel) {
+    return (
+      <div className={cn("space-y-2", className)} {...props}>
+        {errorText ? (
+          <ToolSurface destructive className="px-3 py-2">
+            <div>{errorText}</div>
+          </ToolSurface>
+        ) : typeof output === "string" || typeof output === "object" ? (
+          Output
+        ) : (
+          <ToolSurface tone={tone} className="px-3 py-2">
+            {Output}
+          </ToolSurface>
         )}
+      </div>
+    );
+  }
+
+  return (
+    <ToolSection
+      label={label ?? (errorText ? "Error" : "Result")}
+      className={className}
+      {...props}
+    >
+      <ToolSurface
+        destructive={Boolean(errorText)}
+        tone={tone}
+        className="[&_table]:w-full"
       >
         {errorText && <div>{errorText}</div>}
         {Output}
-      </div>
-    </div>
+      </ToolSurface>
+    </ToolSection>
   );
 };