feat: store tool result content in tool_calls with category blocklist (#96)

## What this does for users

Tool results are now stored and displayed alongside tool calls. When you
expand a tool block, you will see an **output** section showing what the
tool returned — Bash command output, git commit messages, Write
confirmations, and more. Click it to expand the full result, or see the
first line at a glance while it is collapsed.

File-reading results (Read, Glob) are excluded from storage by default
since they are large and rarely useful. The blocklist is configurable:
set `"result_content_blocked_categories": []` in your config file to
store everything, or customize the list to your preference.

Existing databases are upgraded automatically on next startup — no data
is lost.

## Implementation

**Backend**
- **Parser**: extracts tool result content text into a new `Content`
field on `ParsedToolResult`, handling both string and array block
formats
- **DB**: adds `result_content TEXT` to `tool_calls` via a
non-destructive `ALTER TABLE` migration (idempotent probe via
`pragma_table_info`); bumps `dataVersion` 1→2 to trigger resync of
existing sessions
- **Sync**: carries `Content` through `convertToolResults`;
`pairToolResults` now accepts a `blocked map[string]bool` and omits
`ResultContent` for blocked categories (nil map = store everything)
- **Config**: `ResultContentBlockedCategories []string` with default
`["Read", "Glob"]`; config file nil-check allows `[]` to clear the
blocklist entirely

**Frontend**
- **ToolBlock**: adds a collapsible **output** section below the
existing input/meta content, rendered only when `result_content` is
present; collapsed by default with first-line preview; expands to a
scrollable `<pre>` (max 300px height)
- **Types**: `result_content?: string` added to `ToolCall` TypeScript
interface

## Test Plan

- [ ] `make test` passes (all packages)
- [ ] `make build` produces a working binary
- [ ] Existing DB upgraded correctly: start server against real data,
verify `result_content` column appears in `tool_calls` without data loss
- [ ] Bash tool results appear in DB with content and are visible in the
UI output section; Read/Glob results show no output section
- [ ] Output section starts collapsed, first line visible as preview;
click expands full content
- [ ] Override blocklist via config file:
`"result_content_blocked_categories": []` stores and displays content
for all categories

Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: Wes McKinney <wesmckinn+git@gmail.com>

Author: 3 people

cmd/agentsview/main.go

@@ -160,8 +160,9 @@ func runServe(args []string) {
 	cleanResyncTemp(cfg.DBPath)
 
 	engine := sync.NewEngine(database, sync.EngineConfig{
-		AgentDirs: cfg.AgentDirs,
-		Machine:   "local",
+		AgentDirs:               cfg.AgentDirs,
+		Machine:                 "local",
+		BlockedResultCategories: cfg.ResultContentBlockedCategories,
 	})
 
 	if database.NeedsResync() {

frontend/src/lib/api/types/core.ts

@@ -45,6 +45,7 @@ export interface ToolCall {
   input_json?: string;
   skill_name?: string;
   result_content_length?: number;
+  result_content?: string;
   subagent_session_id?: string;
 }
 

frontend/src/lib/components/content/ToolBlock.svelte

@@ -21,6 +21,14 @@
 
   let { content, label, toolCall }: Props = $props();
   let collapsed: boolean = $state(true);
+  let outputCollapsed: boolean = $state(true);
+
+  let outputPreviewLine = $derived.by(() => {
+    const rc = toolCall?.result_content;
+    if (!rc) return "";
+    const nl = rc.indexOf("\n");
+    return (nl === -1 ? rc : rc.slice(0, nl)).slice(0, 100);
+  });
 
   let previewLine = $derived(
     content.split("\n")[0]?.slice(0, 100) ?? "",
@@ -161,6 +169,28 @@
     {:else if fallbackContent}
       <pre class="tool-content">{fallbackContent}</pre>
     {/if}
+    {#if toolCall?.result_content}
+      <button
+        class="output-header"
+        onclick={(e) => {
+          e.stopPropagation();
+          const sel = window.getSelection();
+          if (sel && sel.toString().length > 0) return;
+          outputCollapsed = !outputCollapsed;
+        }}
+      >
+        <span class="tool-chevron" class:open={!outputCollapsed}>
+          &#9656;
+        </span>
+        <span class="output-label">output</span>
+        {#if outputCollapsed && outputPreviewLine}
+          <span class="tool-preview">{outputPreviewLine}</span>
+        {/if}
+      </button>
+      {#if !outputCollapsed}
+        <pre class="tool-content output-content">{toolCall.result_content}</pre>
+      {/if}
+    {/if}
   {/if}
   {#if subagentSessionId}
     <SubagentInline sessionId={subagentSessionId} />
@@ -257,4 +287,38 @@
     overflow-x: auto;
     border-top: 1px solid var(--border-muted);
   }
+
+  .output-header {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 5px 10px;
+    width: 100%;
+    text-align: left;
+    font-size: 12px;
+    color: var(--text-secondary);
+    min-width: 0;
+    border-top: 1px solid var(--border-muted);
+    transition: background 0.1s;
+    user-select: text;
+  }
+
+  .output-header:hover {
+    background: var(--bg-surface-hover);
+    color: var(--text-primary);
+  }
+
+  .output-label {
+    font-family: var(--font-mono);
+    font-weight: 500;
+    font-size: 11px;
+    color: var(--text-secondary);
+    white-space: nowrap;
+    flex-shrink: 0;
+  }
+
+  .output-content {
+    max-height: 300px;
+    overflow-y: auto;
+  }
 </style>

frontend/src/lib/components/content/ToolBlock.test.ts

@@ -0,0 +1,136 @@
+// @vitest-environment jsdom
+// ABOUTME: Unit tests for ToolBlock's output section behavior.
+// ABOUTME: Covers visibility, collapse/expand, and preview of result_content.
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mount, unmount, tick } from "svelte";
+import type { ToolCall } from "../../api/types.js";
+
+vi.mock("./SubagentInline.svelte", () => ({
+  default: {},
+}));
+
+// @ts-ignore
+import ToolBlock from "./ToolBlock.svelte";
+
+describe("ToolBlock output section", () => {
+  let component: ReturnType<typeof mount>;
+
+  afterEach(() => {
+    if (component) unmount(component);
+    document.body.innerHTML = "";
+  });
+
+  it("does not render output-header when toolCall has no result_content", async () => {
+    const toolCall: ToolCall = {
+      tool_name: "Read",
+      category: "file",
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    expect(document.querySelector(".output-header")).toBeNull();
+  });
+
+  it("does not render output-header when toolCall is absent", async () => {
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input" },
+    });
+    await tick();
+
+    expect(document.querySelector(".output-header")).toBeNull();
+  });
+
+  it("renders output-header after expanding the tool block when result_content is set", async () => {
+    const toolCall: ToolCall = {
+      tool_name: "Read",
+      category: "file",
+      result_content: "line one\nline two",
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    // Output section is inside the collapsed block — not visible yet.
+    expect(document.querySelector(".output-header")).toBeNull();
+
+    // Expand the main tool block.
+    const toolHeader = document.querySelector<HTMLButtonElement>(".tool-header");
+    expect(toolHeader).not.toBeNull();
+    toolHeader!.click();
+    await tick();
+
+    expect(document.querySelector(".output-header")).not.toBeNull();
+  });
+
+  it("output starts collapsed after expanding the tool block", async () => {
+    const toolCall: ToolCall = {
+      tool_name: "Read",
+      category: "file",
+      result_content: "line one\nline two",
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    document.querySelector<HTMLButtonElement>(".tool-header")!.click();
+    await tick();
+
+    // Output content pre block should not be present when output is collapsed.
+    expect(document.querySelector(".output-content")).toBeNull();
+  });
+
+  it("expands output content on clicking output-header", async () => {
+    const resultText = "line one\nline two\nline three";
+    const toolCall: ToolCall = {
+      tool_name: "Read",
+      category: "file",
+      result_content: resultText,
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    document.querySelector<HTMLButtonElement>(".tool-header")!.click();
+    await tick();
+
+    document.querySelector<HTMLButtonElement>(".output-header")!.click();
+    await tick();
+
+    const outputContent = document.querySelector(".output-content");
+    expect(outputContent).not.toBeNull();
+    expect(outputContent!.textContent).toBe(resultText);
+  });
+
+  it("shows first line as preview when output is collapsed", async () => {
+    const toolCall: ToolCall = {
+      tool_name: "Read",
+      category: "file",
+      result_content: "first line\nsecond line",
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    document.querySelector<HTMLButtonElement>(".tool-header")!.click();
+    await tick();
+
+    // Output is collapsed — preview should show first line.
+    const outputHeader = document.querySelector(".output-header");
+    expect(outputHeader).not.toBeNull();
+    const preview = outputHeader!.querySelector(".tool-preview");
+    expect(preview).not.toBeNull();
+    expect(preview!.textContent).toBe("first line");
+  });
+});

internal/config/config.go

@@ -34,6 +34,8 @@ type Config struct {
 	// agentDirSource tracks how each agent's dirs were
 	// set so loadFile doesn't override env-set values.
 	agentDirSource map[parser.AgentType]dirSource
+
+	ResultContentBlockedCategories []string `json:"result_content_blocked_categories,omitempty"`
 }
 
 type dirSource int
@@ -82,13 +84,14 @@ func Default() (Config, error) {
 	}
 
 	return Config{
-		Host:           "127.0.0.1",
-		Port:           8080,
-		DataDir:        dataDir,
-		DBPath:         filepath.Join(dataDir, "sessions.db"),
-		WriteTimeout:   30 * time.Second,
-		AgentDirs:      agentDirs,
-		agentDirSource: agentDirSource,
+		Host:                           "127.0.0.1",
+		Port:                           8080,
+		DataDir:                        dataDir,
+		DBPath:                         filepath.Join(dataDir, "sessions.db"),
+		WriteTimeout:                   30 * time.Second,
+		AgentDirs:                      agentDirs,
+		agentDirSource:                 agentDirSource,
+		ResultContentBlockedCategories: []string{"Read", "Glob"},
 	}, nil
 }
 
@@ -138,8 +141,9 @@ func (c *Config) loadFile() error {
 	}
 
 	var file struct {
-		GithubToken  string `json:"github_token"`
-		CursorSecret string `json:"cursor_secret"`
+		GithubToken                    string   `json:"github_token"`
+		CursorSecret                   string   `json:"cursor_secret"`
+		ResultContentBlockedCategories []string `json:"result_content_blocked_categories"`
 	}
 	if err := json.Unmarshal(data, &file); err != nil {
 		return fmt.Errorf("parsing config: %w", err)
@@ -150,6 +154,9 @@ func (c *Config) loadFile() error {
 	if file.CursorSecret != "" {
 		c.CursorSecret = file.CursorSecret
 	}
+	if file.ResultContentBlockedCategories != nil {
+		c.ResultContentBlockedCategories = file.ResultContentBlockedCategories
+	}
 
 	// Parse config-file dir arrays for agents that have a
 	// ConfigKey. Only apply when not already set by env var.

internal/config/config_test.go

@@ -397,3 +397,88 @@ func TestLoadFile_MalformedDirValueLogsWarning(t *testing.T) {
 		)
 	}
 }
+
+func TestDefault_ResultContentBlockedCategories(t *testing.T) {
+	cfg, err := Default()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	want := []string{"Read", "Glob"}
+	if len(cfg.ResultContentBlockedCategories) != len(want) {
+		t.Fatalf(
+			"ResultContentBlockedCategories len = %d, want %d",
+			len(cfg.ResultContentBlockedCategories), len(want),
+		)
+	}
+	for i, v := range cfg.ResultContentBlockedCategories {
+		if v != want[i] {
+			t.Errorf(
+				"ResultContentBlockedCategories[%d] = %q, want %q",
+				i, v, want[i],
+			)
+		}
+	}
+}
+
+func TestLoadFile_ResultContentBlockedCategories(t *testing.T) {
+	tests := []struct {
+		name   string
+		config map[string]any
+		want   []string
+	}{
+		{
+			"NoConfigFileUsesDefault",
+			map[string]any{},
+			[]string{"Read", "Glob"},
+		},
+		{
+			"ConfigFileOverridesWithCustomArray",
+			map[string]any{
+				"result_content_blocked_categories": []string{"Bash"},
+			},
+			[]string{"Bash"},
+		},
+		{
+			"ConfigFileWithMultipleCategories",
+			map[string]any{
+				"result_content_blocked_categories": []string{"Bash", "Write", "Edit"},
+			},
+			[]string{"Bash", "Write", "Edit"},
+		},
+		{
+			"ConfigFileWithEmptyArrayClearsBlocklist",
+			map[string]any{
+				"result_content_blocked_categories": []string{},
+			},
+			[]string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := setupTestEnv(t)
+			writeConfig(t, dir, tt.config)
+
+			cfg, err := LoadMinimal()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if len(cfg.ResultContentBlockedCategories) != len(tt.want) {
+				t.Fatalf(
+					"ResultContentBlockedCategories len = %d, want %d",
+					len(cfg.ResultContentBlockedCategories), len(tt.want),
+				)
+			}
+			for i, v := range cfg.ResultContentBlockedCategories {
+				if v != tt.want[i] {
+					t.Errorf(
+						"ResultContentBlockedCategories[%d] = %q, want %q",
+						i, v, tt.want[i],
+					)
+				}
+			}
+		})
+	}
+}