fix(compact): harden pruning integration (round 2)

packages/ui/acp/README.md

@@ -99,7 +99,7 @@ The JSON-RPC frames go on stdout, so this plugin MUST run in an example that loa
 
 **What the model sees**: When optional consumers are loaded, ACP form answers become the exact JSON shape documented by `dsh-tool-ask-user`. Failures become `Error: ACP user questions must come from an agent-owned request`, `Error: ACP user question has no matching session`, `Error: ACP elicitation request failed`, `Error: ask_user_question was cancelled by the user`, `Error: ask_user_question returned no answer`, or `Error: ask_user_question was aborted before the user answered`. Permission decisions control whether another tool yields success or denial. ACP tool cards, terminal output, diffs, and streamed session updates are UI-only.
 
-**Token effect**: Answer, error, and denial text enters context only through the owning tool result; presentation metadata adds zero model tokens.
+**Token effect**: Answer, error, and denial text enters context only through the owning tool result; presentation metadata adds zero model tokens. A replacement `tool/result` still changes the model-facing session surface, but live and replayed ACP feeds ignore it as an execution update so the original terminal or diff completion is not overwritten.
 
 ### Permission preset switches
 

packages/ui/acp/acp-feature-support.md

@@ -82,7 +82,7 @@ These are capabilities the bridge would *drive* on the editor. The harness runs
 | `agent_thought_chunk` | S | ✅ | ✅ | ✅ | From `assistant/chunk` reasoning-delta. |
 | `user_message_chunk` | S | ✅ | ✅ | ✅ | Emitted during `session/load` replay to reconstruct the user side. |
 | `tool_call` | S | ✅ | ✅ | ✅ | Tool-owned presentation (`presentCall`); see [§5](#5-tool-call-rendering). |
-| `tool_call_update` | S | ✅ | ✅ | ✅ | From `tool/result` via `presentResult`. |
+| `tool_call_update` | S | ✅ | ✅ | ✅ | From appended `tool/result` via `presentResult`; replacement results rewrite model context and do not duplicate or overwrite execution presentation. |
 | `plan` | S | ❌ | ✅ | ✅ | No agent plan emitted. Both adapters emit real plan entries (Codex's `CodexEventHandler.updatePlan` maps `turn/plan/updated` → `{ sessionUpdate: 'plan', entries }`). |
 | `available_commands_update` | S | ❌ | ✅ | ✅ | No slash commands advertised. |
 | `current_mode_update` | S | ❌ | ✅ | ✅ | No session modes. |

packages/ui/acp/src/index.ts

@@ -904,7 +904,8 @@ function validateMcpServers(params: { mcpServers?: unknown[] }): void {
  *   loaded transcript reconstructs the USER side of each turn without echoing
  *   a live `session/prompt` back to the client
  * - `tool/call`   → `tool_call` (pending)
- * - `tool/result` → `tool_call_update` (completed/failed)
+ * - appended `tool/result` → `tool_call_update` (completed/failed)
+ * - replacement `tool/result` → no update (context rewrite, not execution)
  *
  * Tool-call presentation (title/kind/rawInput, and the completed-state content)
  * is owned by each TOOL via `presentCall`/`presentResult` — the bridge never
@@ -965,6 +966,10 @@ export function streamSessionEventUpdate(
       return
     }
     case 'tool/result': {
+      // Replacements (for example model-free pruning) are transcript rewrites,
+      // not repeated tool executions. Re-presenting one would consume no
+      // pending call and could clobber the original terminal/diff completion.
+      if (event.surfaceOp !== undefined && event.surfaceOp !== 'append') return
       const view = presenter.result(event.data.callId, event.data.content, event.data.isError, event.data.meta)
       notify({ sessionId, update: toolResultUpdate(event.data.callId, view, event.data.isError, terminal) })
       return

packages/ui/acp/tests/load.spec.ts

@@ -162,6 +162,53 @@ describe('acp bridge — session/load replay', () => {
     expect(meta.terminal_exit?.exit_code).toBe(0)
   })
 
+  it('keeps one terminal completion live and on replay when a pruning replacement is logged', async () => {
+    live = await makeBridgeHarness({
+      storageDir,
+      withBash: true,
+      script: [toolCallResponse('c1', 'bash', { command: 'echo full', description: 'Print full output' }), textResponse('done')],
+    })
+    await live.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: { _meta: { terminal_output: true } } })
+    const { sessionId } = await live.client.newSession({ cwd: process.cwd(), mcpServers: [] })
+    await live.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'run it' }] })
+
+    const session = live.ctx.agents.get(AgentId(sessionId))!.session
+    const original = session.events.find(event => event.type === 'tool/result')
+    if (original?.type !== 'tool/result') throw new Error('expected original tool/result')
+    const liveCompletions = () => live!.updates.filter(update =>
+      update.sessionUpdate === 'tool_call_update' && update.toolCallId === 'c1')
+    expect(liveCompletions()).toHaveLength(1)
+    expect((liveCompletions()[0] as { _meta?: { terminal_output?: { data: string } } })._meta?.terminal_output?.data)
+      .toBe('full\n')
+
+    session.append('turn/start', { turn: 2, trigger: { kind: 'message', source: { kind: 'user' } } })
+    session.append('tool/result', {
+      ...original.data,
+      content: [{ type: 'text', text: '[... tool result middle pruned ...]' }],
+    }, {
+      surfaceOp: { op: 'replace', start: original.seq, end: original.seq },
+      sourceEventSeqs: [original.seq],
+    })
+    session.append('turn/end', { turn: 2, reason: { kind: 'completed' } })
+
+    // The replacement is durable but is not another live completion.
+    expect(session.events.filter(event => event.type === 'tool/result')).toHaveLength(2)
+    expect(JSON.stringify(session.deriveMessages())).toContain('tool result middle pruned')
+    expect(liveCompletions()).toHaveLength(1)
+    await live.dispose()
+    live = undefined
+
+    loader = await makeBridgeHarness({ storageDir, withBash: true, script: [] })
+    await loader.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: { _meta: { terminal_output: true } } })
+    await loader.client.loadSession({ sessionId, cwd: process.cwd(), mcpServers: [] })
+
+    const replayed = loader.updates.filter(update =>
+      update.sessionUpdate === 'tool_call_update' && update.toolCallId === 'c1')
+    expect(replayed).toHaveLength(1)
+    expect((replayed[0] as { _meta?: { terminal_output?: { data: string } } })._meta?.terminal_output?.data)
+      .toBe('full\n')
+  })
+
   it('a load whose resume finishes after a client disconnect leaks no live session', async () => {
     // Stall persistence so transport closes while resume is pending. Whether the SDK rejects first
     // or the bridge's post-await guard fires, no agent may survive for the dead connection.

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

@@ -105,6 +105,22 @@ describe('streamSessionEventUpdate', () => {
     expect((failed[0] as { status: string }).status).toBe('failed')
   })
 
+  it('emits no execution update for a tool-result surface replacement', () => {
+    const replacement = {
+      ...evt('tool/result', {
+        turn: 1,
+        step: 1,
+        callId: CallId('c1'),
+        content: [{ type: 'text', text: '[... tool result middle pruned ...]' }],
+        isError: false,
+      }),
+      seq: 2,
+      surfaceOp: { op: 'replace', start: 1, end: 1 },
+      sourceEventSeqs: [1],
+    } as SessionEvent
+    expect(updatesFor(replacement)).toEqual([])
+  })
+
   it('drops non-text tool-result content (text-only)', () => {
     const update = updatesFor(evt('tool/result', {
       turn: 1, step: 1, callId: CallId('c1'),
@@ -450,6 +466,16 @@ describe('terminal-card mapping (capability-gated)', () => {
 
   const callEvent = evt('tool/call', { turn: 1, step: 1, callId: CallId('c1'), name: 'bash', arguments: JSON.stringify({ command: 'echo hi', description: 'Greet' }) })
   const resultEvent = evt('tool/result', { turn: 1, step: 1, callId: CallId('c1'), content: [{ type: 'text', text: 'hi\n' }], isError: false })
+  const prunedResultEvent = {
+    ...resultEvent,
+    seq: 2,
+    data: {
+      ...resultEvent.data,
+      content: [{ type: 'text', text: '[... tool result middle pruned ...]' }],
+    },
+    surfaceOp: { op: 'replace', start: 1, end: 1 },
+    sourceEventSeqs: [1],
+  } as SessionEvent
 
   function termUpdates(tool: ToolDefinition, enabled: boolean, cwd: string | undefined, ...events: SessionEvent[]): SessionNotification['update'][] {
     const presenter = new ToolPresenter(registryOf(tool))
@@ -477,6 +503,27 @@ describe('terminal-card mapping (capability-gated)', () => {
     })
   })
 
+  it('live/replay translation preserves the original terminal completion across a pruning rewrite', () => {
+    const updates = termUpdates(
+      termTool({ card: 'terminal' }, { output: 'hi\n', exitCode: 0 }),
+      true,
+      '/work/proj',
+      callEvent,
+      resultEvent,
+      prunedResultEvent,
+    )
+    expect(updates).toHaveLength(2)
+    expect(updates[1]).toEqual({
+      sessionUpdate: 'tool_call_update',
+      toolCallId: 'c1',
+      status: 'completed',
+      _meta: {
+        terminal_output: { terminal_id: 'c1', data: 'hi\n' },
+        terminal_exit: { terminal_id: 'c1', exit_code: 0 },
+      },
+    })
+  })
+
   it('capability ON: an ABSOLUTE tool cwd wins; a RELATIVE one resolves against the session cwd', () => {
     const [absCall] = termUpdates(termTool({ card: 'terminal', cwd: '/explicit/abs' }, { output: 'x' }), true, '/work/proj', callEvent)
     expect((absCall as unknown as { _meta: { terminal_info: { cwd: string } } })._meta.terminal_info.cwd).toBe('/explicit/abs')
@@ -633,17 +680,38 @@ describe('result-time diff card (REAL fs edit tool → tool_call_update diff blo
   // 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. The real tool is required because its result metadata is the contract.
-  it('forwards the applied-hunk meta onto the wire as tool_call_update diff content', async () => {
+  it('live/replay translation keeps the applied diff when a pruning rewrite follows', 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(
+    const originalResult = evt('tool/result', {
+      turn: 1,
+      step: 1,
+      callId: CallId('e1'),
+      content: [{ type: 'text', text: 'ok' }],
+      isError: false,
+      meta,
+    })
+    const replacement = {
+      ...originalResult,
+      seq: 3,
+      data: {
+        ...originalResult.data,
+        content: [{ type: 'text', text: '[... tool result middle pruned ...]' }],
+      },
+      surfaceOp: { op: 'replace', start: 2, end: 2 },
+      sourceEventSeqs: [2],
+    } as SessionEvent
+    const updates = 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 }),
+      originalResult,
+      replacement,
     )
+    expect(updates).toHaveLength(2)
+    const resultUpdate = updates[1]
     expect(resultUpdate).toEqual({
       sessionUpdate: 'tool_call_update',
       toolCallId: 'e1',

packages/ui/stdio/README.md

@@ -27,7 +27,7 @@ The plugin seeds display labels from the live agent registry, then tracks `agent
 
 **What the model sees**: Each non-empty terminal line outside an active question becomes one text block, sent with `agent.send()` while the target agent is idle and `agent.steer()` while it is running.
 
-**Token effect**: Submitted text is retained under the agent loop's normal session-history and compaction rules. The welcome banner, `> ` prompt, rendered transcript, and `[tool call]` / `[tool result]` terminal lines add no tokens.
+**Token effect**: Submitted text is retained under the agent loop's normal session-history and compaction rules. The welcome banner, `> ` prompt, rendered transcript, and `[tool call]` / `[tool result]` terminal lines add no tokens. A replacement `tool/result` remains model-visible through the session surface but is not rendered as a second execution; stdio keeps the original full-fidelity result line.
 
 ### Terminal user-interaction answers
 

packages/ui/stdio/src/index.ts

@@ -124,6 +124,10 @@ export function createStdioChat(ctx: Context, config: Config, runtime: StdioRunt
       inReasoning = false
       output.write(`\n  [tool call] ${toolName}(${args})`)
     } else if (event.type === 'tool/result') {
+      // A surface replacement changes future model context; it is not another
+      // execution. Keep the original full-fidelity terminal presentation and
+      // suppress duplicate output during live delivery or log replay.
+      if (event.surfaceOp !== undefined && event.surfaceOp !== 'append') return
       const { content } = event.data
       const text = content.filter(block => block.type === 'text').map(block => block.text).join('')
       output.write(`\n  [tool result] ${text}\n  `)

packages/ui/stdio/tests/stdio.spec.ts

@@ -288,6 +288,43 @@ describe('createStdioChat rendering', () => {
     expect(out.text()).toContain('[tool result] file.txt')
   })
 
+  it('renders one full-fidelity result whether the event feed is live or replayed', async () => {
+    const { ctx, out } = await setup()
+    const session = makeSession('main')
+    const original = {
+      type: 'tool/result',
+      seq: 2,
+      time: 0,
+      data: {
+        turn: 1,
+        step: 1,
+        callId: 'c1',
+        content: [{ type: 'text', text: 'full terminal output' }],
+        isError: false,
+        meta: { terminal: { output: 'full terminal output' } },
+      },
+      surfaceOp: 'append',
+    } as SessionEvent
+    const replacement = {
+      ...original,
+      seq: 3,
+      data: {
+        ...original.data,
+        content: [{ type: 'text', text: '[... tool result middle pruned ...]' }],
+      },
+      surfaceOp: { op: 'replace', start: 2, end: 2 },
+      sourceEventSeqs: [2],
+    } as SessionEvent
+
+    // Stdio consumes the same session/event shape whether a host forwards a
+    // live append or replays a stored log through the rendering feed.
+    for (const event of [original, replacement]) ctx.emit('session/event', session, event)
+
+    expect(out.text().match(/\[tool result\]/g)).toHaveLength(1)
+    expect(out.text()).toContain('full terminal output')
+    expect(out.text()).not.toContain('tool result middle pruned')
+  })
+
   it('renders a todo/write session event as a glyphed checklist', async () => {
     const { ctx, out } = await setup()
     const session = {} as Session