feat: model Codex subagent result events (#247)

Closes #233.
Supersedes #242.

## Summary

- model Codex subagent terminal status as first-class
`tool_result_events` in SQLite and PostgreSQL
- keep `tool_calls.result_content` as a derived/latest compatibility
summary instead of the canonical storage shape
- render the latest summary by default and expose full chronological
subagent result history in the tool block UI
- preserve event history across full resyncs, PG pushes, and orphan-copy
recovery

## How This Differs From #242

`#242` tried to solve Codex subagent workflows inside the existing
single-result model by:

- rebinding `wait` / `<subagent_notification>` output into one mutable
`tool_calls.result_content`
- synthesizing tool-result-like transcript rows to preserve some
ordering information
- adding parser heuristics to decide which source should "own" the final
blob

That approach improved the raw JSON problem, but it kept running into
ownership and chronology edge cases because Codex subagent status is not
actually a single final blob.

This PR switches to a different model:

- add additive `tool_result_events` tables in both SQLite and PostgreSQL
- attach chronological result events directly to the originating tool
call
- derive `tool_calls.result_content` from those events for
compatibility/search/compact UI
- keep the existing subagent session linkage on `spawn_agent`

Practical effect:

- chronology is preserved without retroactively mutating older
transcript rows
- `wait` output and fallback notifications are stored as canonical event
history
- PG-backed multi-host views and local SQLite views share the same
result-event model

## Details

- `spawn_agent` remains a `Task` tool call and still maps to
`subagent_session_id`
- terminal `wait` output becomes `tool_result_events`
- terminal `<subagent_notification>` messages also become
`tool_result_events`
- blocked categories are enforced server-side for event history as well
as the compact summary
- orphan-copy / resync paths preserve stored event history for sessions
whose source files no longer exist

## Upgrade / Rollout

- SQLite: additive schema change plus `dataVersion` bump
- PostgreSQL: additive schema change, no drop/recreate required
- exporters should upgrade and run `agentsview pg push --full` once, or
let the normal full-sync path re-export after resync

Known limit:

- sessions whose original Codex JSONL source is already gone can only
preserve event history that was already stored in SQLite; they cannot
derive brand new history from missing raw files

## Test Plan

- `CC=/usr/bin/gcc CXX=/usr/bin/g++ CGO_ENABLED=1 go test -tags fts5
./internal/parser ./internal/sync ./internal/db ./internal/postgres
-count=1`
- `cd frontend && npm test -- --run
src/lib/components/content/ToolBlock.test.ts
src/lib/utils/messages.test.ts`

## Local Review

- local `codex`, `claude-code`, and `gemini` review runs covered both
`default` and `security`
- the first v2 pass surfaced issues around stale `tool_result_events`,
blocked-category history leakage, and same-ordinal orphan chronology
- those follow-up fixes are included in this branch

Author: tpn

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

@@ -41,6 +41,19 @@ export interface ProjectInfo {
   session_count: number;
 }
 
+/** Matches Go ToolResultEvent struct in internal/db/messages.go */
+export interface ToolResultEvent {
+  tool_use_id?: string;
+  agent_id?: string;
+  subagent_session_id?: string;
+  source: string;
+  status: string;
+  content: string;
+  content_length: number;
+  timestamp?: string;
+  event_index: number;
+}
+
 /** Matches Go ToolCall struct in internal/db/messages.go */
 export interface ToolCall {
   tool_name: string;
@@ -51,6 +64,7 @@ export interface ToolCall {
   result_content_length?: number;
   result_content?: string;
   subagent_session_id?: string;
+  result_events?: ToolResultEvent[];
 }
 
 /** Matches Go Message struct in internal/db/messages.go */

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

@@ -20,10 +20,13 @@
   let { content, label, toolCall, highlightQuery = "", isCurrentHighlight = false }: Props = $props();
   let userCollapsed: boolean = $state(true);
   let userOutputCollapsed: boolean = $state(true);
+  let userHistoryCollapsed: boolean = $state(true);
   let userOverride: boolean = $state(false);
   let userOutputOverride: boolean = $state(false);
+  let userHistoryOverride: boolean = $state(false);
   let searchExpandedInput: boolean = $state(false);
   let searchExpandedOutput: boolean = $state(false);
+  let searchExpandedHistory: boolean = $state(false);
   let prevQuery: string = "";
 
   // Auto-expand when a search match exists in input or output
@@ -41,14 +44,19 @@
     const inputText = (
       taskPrompt ?? content ?? fallbackContent ?? ""
     ).toLowerCase();
+    const historyText = (
+      toolCall?.result_events?.map((event) => event.content).join("\n\n") ?? ""
+    ).toLowerCase();
     const outputText = (
-      toolCall?.result_content ?? ""
+      [toolCall?.result_content ?? "", historyText].filter(Boolean).join("\n\n")
     ).toLowerCase();
     searchExpandedInput = inputText.includes(q);
     searchExpandedOutput = outputText.includes(q);
+    searchExpandedHistory = historyText.includes(q);
     if (hq !== prevQuery) {
       userOverride = false;
       userOutputOverride = false;
+      userHistoryOverride = false;
       prevQuery = hq;
     }
   });
@@ -63,6 +71,11 @@
       : searchExpandedOutput ? false
       : userOutputCollapsed,
   );
+  let historyCollapsed = $derived(
+    userHistoryOverride ? userHistoryCollapsed
+      : searchExpandedHistory ? false
+      : userHistoryCollapsed,
+  );
 
   let outputPreviewLine = $derived.by(() => {
     const rc = toolCall?.result_content;
@@ -71,6 +84,14 @@
     return (nl === -1 ? rc : rc.slice(0, nl)).slice(0, 100);
   });
 
+  let resultEvents = $derived(toolCall?.result_events ?? []);
+
+  let historyPreviewLine = $derived.by(() => {
+    const last = resultEvents[resultEvents.length - 1];
+    if (!last) return "";
+    return `${last.status}: ${last.content.split("\n")[0]}`.slice(0, 100);
+  });
+
   /** Parsed input parameters from structured tool call data */
   let inputParams = $derived.by(() => {
     if (!toolCall?.input_json) return null;
@@ -247,6 +268,51 @@
         <pre class="tool-content output-content" use:applyHighlight={{ q: highlightQuery, current: isCurrentHighlight, content: toolCall.result_content }}>{@html escapeHTML(toolCall.result_content)}</pre>
       {/if}
     {/if}
+    {#if resultEvents.length > 0}
+      <button
+        class="history-header"
+        onclick={(e) => {
+          e.stopPropagation();
+          const sel = window.getSelection();
+          if (sel && sel.toString().length > 0) return;
+          userHistoryCollapsed = !userHistoryCollapsed;
+          userHistoryOverride = true;
+        }}
+      >
+        <span class="tool-chevron" class:open={!historyCollapsed}>
+          &#9656;
+        </span>
+        <span class="output-label">history</span>
+        {#if historyCollapsed && historyPreviewLine}
+          <span class="tool-preview">{historyPreviewLine}</span>
+        {/if}
+      </button>
+      {#if !historyCollapsed}
+        <div class="result-history">
+          {#each resultEvents as event (event.event_index)}
+            <div class="result-event">
+              <div class="result-event-meta">
+                <span class="meta-tag">
+                  <span class="meta-label">status:</span>
+                  {event.status}
+                </span>
+                <span class="meta-tag">
+                  <span class="meta-label">source:</span>
+                  {event.source}
+                </span>
+                {#if event.agent_id}
+                  <span class="meta-tag">
+                    <span class="meta-label">agent:</span>
+                    {event.agent_id}
+                  </span>
+                {/if}
+              </div>
+              <pre class="tool-content output-content history-content" use:applyHighlight={{ q: highlightQuery, current: isCurrentHighlight, content: event.content }}>{@html escapeHTML(event.content)}</pre>
+            </div>
+          {/each}
+        </div>
+      {/if}
+    {/if}
   {/if}
   {#if subagentSessionId}
     <SubagentInline sessionId={subagentSessionId} />
@@ -364,6 +430,26 @@
     color: var(--text-primary);
   }
 
+  .history-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;
+  }
+
+  .history-header:hover {
+    background: var(--bg-surface-hover);
+    color: var(--text-primary);
+  }
+
   .output-label {
     font-family: var(--font-mono);
     font-weight: 500;
@@ -377,4 +463,24 @@
     max-height: 300px;
     overflow-y: auto;
   }
+
+  .result-history {
+    border-top: 1px solid var(--border-muted);
+  }
+
+  .result-event + .result-event {
+    border-top: 1px solid var(--border-muted);
+  }
+
+  .result-event-meta {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    padding: 6px 14px 0;
+  }
+
+  .history-content {
+    border-top: 0;
+    margin-top: 0;
+  }
 </style>

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

@@ -133,6 +133,77 @@ describe("ToolBlock output section", () => {
     expect(preview).not.toBeNull();
     expect(preview!.textContent).toBe("first line");
   });
+
+  it("renders history after expanding the tool block when result_events are set", async () => {
+    const toolCall: ToolCall = {
+      tool_name: "wait",
+      category: "Other",
+      result_content: "latest summary",
+      result_events: [
+        {
+          source: "wait_output",
+          status: "completed",
+          content: "Finished successfully",
+          content_length: 21,
+          agent_id: "agent-1",
+          event_index: 0,
+        },
+      ],
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    expect(document.querySelector(".history-header")).toBeNull();
+
+    document.querySelector<HTMLButtonElement>(".tool-header")!.click();
+    await tick();
+
+    expect(document.querySelector(".history-header")).not.toBeNull();
+  });
+
+  it("expands event history and shows chronological event content", async () => {
+    const toolCall: ToolCall = {
+      tool_name: "wait",
+      category: "Other",
+      result_content: "agent-a:\nFirst finished\n\nagent-b:\nSecond finished",
+      result_events: [
+        {
+          source: "wait_output",
+          status: "completed",
+          content: "First finished",
+          content_length: 14,
+          agent_id: "agent-a",
+          event_index: 0,
+        },
+        {
+          source: "subagent_notification",
+          status: "completed",
+          content: "Second finished",
+          content_length: 15,
+          agent_id: "agent-b",
+          event_index: 1,
+        },
+      ],
+    };
+    component = mount(ToolBlock, {
+      target: document.body,
+      props: { content: "some input", toolCall },
+    });
+    await tick();
+
+    document.querySelector<HTMLButtonElement>(".tool-header")!.click();
+    await tick();
+    document.querySelector<HTMLButtonElement>(".history-header")!.click();
+    await tick();
+
+    const historyEntries = Array.from(document.querySelectorAll(".history-content"));
+    expect(historyEntries).toHaveLength(2);
+    expect(historyEntries[0].textContent).toBe("First finished");
+    expect(historyEntries[1].textContent).toBe("Second finished");
+  });
 });
 
 describe("ToolBlock fallback content", () => {

internal/db/db.go

@@ -23,7 +23,7 @@ import (
 // formatting changes). Old databases with a lower user_version
 // trigger a non-destructive re-sync (mtime reset + skip cache
 // clear) so existing session data is preserved.
-const dataVersion = 6
+const dataVersion = 7
 
 //go:embed schema.sql
 var schemaSQL string