feat(tool-fs): result-time applied-hunk diffs for write/edit

fs write/edit now emit a result-time contextual-diff tool_call_update
(the applied hunk with ±3 context lines, one hunk per replace_all site),
matching what claude-agent-acp sends and what makes an editor render the
change in place. The call-time snippet diff stays; the result hunk
supersedes it (ACP content-replace).

Mechanism:
- A persisted tool-private `meta` channel: execute may return
  `{ content, meta }`; `meta` (JsonValue) rides on the tool/result event
  and is handed back to presentResult, so the diff reproduces on replay
  (event-sourced). JsonValue is now exported from dsh-session.
- The backend returns raw before/after text (storage facts) on
  FsWriteOutcome/FsEditOutcome; the tool computes the hunk via the npm
  `diff` package's structuredPatch. A create has no before → no result
  diff; a failed/aborted mutation carries no meta.
- ToolResultView gains a DiffResultView; the bridge's result-side switch
  renders it as {type:'diff'} content blocks.

RFC: docs/rfc/implemented/architecture/2026-07-02-result-time-applied-hunk-diffs.md
(justifies the npm `diff` runtime dep over vendoring and the meta channel);
the render-intent-union RFC's Non-goal is updated to record this shipped.
All fs snapshot goldens re-recorded; edit/overwrite gain the contextual
result diff, create/read/policy-reject unchanged in structure.

packages/ui/acp/tests/stream-update.spec.ts

@@ -618,6 +618,92 @@ describe('diff-card mapping', () => {
   })
 })
 
+describe('result-time diff card (REAL fs edit tool → tool_call_update diff blocks)', () => {
+  // Drive the SHIPPING fs edit tool through the bridge: the pending tool/call
+  // installs the call-time snippet, then the tool/result carries the tool's
+  // computed applied-hunk `meta`, which presentResult narrows into a `diff`
+  // result card the bridge forwards as `{ type: 'diff' }` content blocks. Uses
+  // the REAL tool (not a stand-in) per the anti-mock convention, mirroring the
+  // call-side diff test above.
+  async function fsCtx(): Promise<Context> {
+    const ctx = new Context()
+    await ctx.plugin(SystemPrompt)
+    await ctx.plugin(ToolRegistry)
+    await ctx.plugin(FsLocal)
+    await ctx.plugin(ToolFs)
+    return ctx
+  }
+
+  function updatesWith(presenter: ToolPresenter, ...events: SessionEvent[]): SessionNotification['update'][] {
+    const out: SessionNotification['update'][] = []
+    for (const event of events) streamSessionEventUpdate(SessionId('s1'), event, n => out.push(n.update), presenter)
+    return out
+  }
+
+  it('forwards the applied-hunk meta onto the wire as tool_call_update diff content', async () => {
+    const ctx = await fsCtx()
+    const presenter = new ToolPresenter(ctx.tools)
+    const args = JSON.stringify({ file_path: 'src/b.ts', old_string: 'OLD', new_string: 'NEW' })
+    // The applied hunk the tool would compute and persist on the result meta.
+    const meta = { diffs: [{ path: 'src/b.ts', oldText: 'a\nOLD\nb', newText: 'a\nNEW\nb' }] }
+    const [, resultUpdate] = updatesWith(
+      presenter,
+      evt('tool/call', { turn: 1, step: 1, callId: CallId('e1'), name: 'edit', arguments: args }),
+      evt('tool/result', { turn: 1, step: 1, callId: CallId('e1'), content: [{ type: 'text', text: 'ok' }], isError: false, meta }),
+    )
+    expect(resultUpdate).toEqual({
+      sessionUpdate: 'tool_call_update',
+      toolCallId: 'e1',
+      status: 'completed',
+      title: 'Edit src/b.ts',
+      content: [{ type: 'diff', path: 'src/b.ts', oldText: 'a\nOLD\nb', newText: 'a\nNEW\nb' }],
+    })
+    await ctx.fiber.dispose()
+  })
+
+  it('an error result carries NO diff card (falls back to raw content)', async () => {
+    const ctx = await fsCtx()
+    const presenter = new ToolPresenter(ctx.tools)
+    const args = JSON.stringify({ file_path: 'src/b.ts', old_string: 'OLD', new_string: 'NEW' })
+    const [, resultUpdate] = updatesWith(
+      presenter,
+      evt('tool/call', { turn: 1, step: 1, callId: CallId('e1'), name: 'edit', arguments: args }),
+      evt('tool/result', { turn: 1, step: 1, callId: CallId('e1'), content: [{ type: 'text', text: 'Error: boom' }], isError: true }),
+    )
+    expect(resultUpdate).toMatchObject({ sessionUpdate: 'tool_call_update', status: 'failed' })
+    expect(resultUpdate).not.toHaveProperty('content', expect.arrayContaining([expect.objectContaining({ type: 'diff' })]))
+    await ctx.fiber.dispose()
+  })
+
+  it('a diff result with an EMPTY diffs array and no title omits both keys (nothing to send)', () => {
+    // A synthetic tool whose presentResult yields a `diff` card with no hunks and
+    // no title — the shipping fs tools never emit this (edit always has a hunk; an
+    // empty write returns undefined), so a stand-in is the only way to exercise
+    // the empty-content AND absent-title branches of the result-side diff arm.
+    const emptyDiffTool: ToolDefinition = {
+      name: 'writer',
+      description: 'writes a file',
+      parameters: {},
+      execute: async () => [],
+      presentCall: () => ({ card: 'diff', title: 'Write x', diffs: [{ path: 'x', oldText: null, newText: 'y' }] }),
+      presentResult: () => ({ card: 'diff', diffs: [] }),
+    }
+    const presenter = new ToolPresenter(registryOf(emptyDiffTool))
+    const [, resultUpdate] = updatesWith(
+      presenter,
+      evt('tool/call', { turn: 1, step: 1, callId: CallId('w1'), name: 'writer', arguments: '{}' }),
+      evt('tool/result', { turn: 1, step: 1, callId: CallId('w1'), content: [{ type: 'text', text: 'ok' }], isError: false }),
+    )
+    expect(resultUpdate).toEqual({
+      sessionUpdate: 'tool_call_update',
+      toolCallId: 'w1',
+      status: 'completed',
+    })
+    expect(resultUpdate).not.toHaveProperty('content')
+    expect(resultUpdate).not.toHaveProperty('title')
+  })
+})
+
 describe('relative-path display titles (bridge relativizes the title against the session cwd)', () => {
   // The bridge relativizes a file card's TITLE against the session workspace cwd
   // (mirroring the reference adapter's toDisplayPath), while leaving locations/