feat(tool-fs): editor-facing presentation for read/write/edit

The fs tools rendered as generic cards (title = tool name, raw file content) in
an ACP editor. Give them tool-owned presentation like bash/subagent have:

- read → title "Read <path>", kind read, offset/limit as rawInput
- write → title "Write <path>", kind edit
- edit → title "Edit <path>", kind edit, a clipped old→new rawInput summary

Add a provider-neutral `locations: { path, line? }[]` to ToolCallPresentation —
the files a call reads/modifies — so a capable editor can follow along / jump to
the file (read carries its offset as the line). The ACP bridge forwards it onto
the wire `tool_call` (ResolvedCallPresentation + call() + the tool_call build in
streamSessionEventUpdate). This flips the `locations` cell in the ACP feature
matrix to supported. The SDK already carries `tool_call.locations`
(ToolCallLocation `{ path, line? }`), so no ACP types leak into dsh-tools.

presentResult is intentionally omitted: it only receives `{ content, isError }`,
not the write/edit outcome, so titling by create-vs-overwrite or replacement
count would mean parsing the model-facing text — the static title stays.

Tests: pure presentCall assertions for all three tools incl. locations and the
edit rawInput clip; a bridge test drives the REAL fs tools through ToolPresenter
and asserts locations reaches the wire tool_call (proven to fail without the
forwarding line). New withFs harness option + dsh-fs devDeps on dsh-acp.

packages/fs/tool-fs/src/edit.ts

@@ -83,5 +83,18 @@ export function applyEditTool(ctx: Context): void {
       ctx.emit('fs/observed', target, outcome.version, exec)
       return [{ type: 'text', text: formatEditOutput(target.displayPath, outcome) }]
     },
+    // Pure display: `edit` kind, a location for editor follow-along, and a short
+    // old→new summary as rawInput (truncated so a large replacement stays a
+    // readable card). The replacement COUNT is not available here — presentResult
+    // only sees `{ content, isError }`, not the outcome — so the title is static.
+    presentCall(args) {
+      const clip = (s: string): string => (s.length > 40 ? `${s.slice(0, 40)}…` : s)
+      return {
+        title: `Edit ${args.file_path}`,
+        kind: 'edit',
+        rawInput: `${JSON.stringify(clip(args.old_string))} → ${JSON.stringify(clip(args.new_string))}`,
+        locations: [{ path: args.file_path }],
+      }
+    },
   }))
 }

packages/fs/tool-fs/src/read.ts

@@ -101,5 +101,20 @@ export function applyReadTool(ctx: Context): void {
       ctx.emit('fs/observed', target, info.version, exec)
       return [{ type: 'text', text: formatReadOutput(target.displayPath, outcome) }]
     },
+    // Pure display: a UI card titled by the file, `read` kind (icon), and a
+    // location so an editor can follow along to the file (and the read's offset
+    // line). `rawInput` surfaces offset/limit when the model narrowed the read.
+    presentCall(args) {
+      const detail = [
+        ...args.offset !== undefined ? [`offset ${args.offset}`] : [],
+        ...args.limit !== undefined ? [`limit ${args.limit}`] : [],
+      ].join(', ')
+      return {
+        title: `Read ${args.file_path}`,
+        kind: 'read',
+        locations: [{ path: args.file_path, ...args.offset !== undefined ? { line: args.offset } : {} }],
+        ...detail.length > 0 ? { rawInput: detail } : {},
+      }
+    },
   }))
 }

packages/fs/tool-fs/src/write.ts

@@ -62,5 +62,12 @@ export function applyWriteTool(ctx: Context): void {
       ctx.emit('fs/observed', target, outcome.version, exec)
       return [{ type: 'text', text: formatWriteOutput(target.displayPath, outcome) }]
     },
+    // Pure display: `edit` kind (an editor treats create/replace as an edit) and
+    // a location so the UI can follow along to the written file. The create-vs-
+    // overwrite fact lives in the model-facing result text; `presentResult` only
+    // sees `{ content, isError }` (not the outcome), so the title stays static.
+    presentCall(args) {
+      return { title: `Write ${args.file_path}`, kind: 'edit', locations: [{ path: args.file_path }] }
+    },
   }))
 }

packages/fs/tool-fs/tests/tools.spec.ts

@@ -320,3 +320,43 @@ describe('edit tool', () => {
     expect(result.error).toMatchObject({ code: 'FS_NOT_OBSERVED' })
   })
 })
+
+describe('tool-owned presentation (pure presentCall)', () => {
+  // presentCall is a pure display function of args (no I/O); it drives the ACP
+  // card's title/kind and the `locations` an editor follows along to.
+  const presentCall = async (name: string, args: unknown) => {
+    const { ctx } = await setup()
+    return ctx.tools.get(name)?.presentCall?.(args)
+  }
+
+  it('read: titles by file, read kind, location with the offset line', async () => {
+    expect(await presentCall('read', { file_path: 'src/a.ts', offset: 12, limit: 40 })).toEqual({
+      title: 'Read src/a.ts', kind: 'read', rawInput: 'offset 12, limit 40',
+      locations: [{ path: 'src/a.ts', line: 12 }],
+    })
+  })
+
+  it('read: omits rawInput and the location line when offset/limit are unset', async () => {
+    expect(await presentCall('read', { file_path: 'a.txt' })).toEqual({
+      title: 'Read a.txt', kind: 'read', locations: [{ path: 'a.txt' }],
+    })
+  })
+
+  it('write: titles by file, edit kind, location', async () => {
+    expect(await presentCall('write', { file_path: 'out.txt', content: 'x' })).toEqual({
+      title: 'Write out.txt', kind: 'edit', locations: [{ path: 'out.txt' }],
+    })
+  })
+
+  it('edit: titles by file, edit kind, an old→new rawInput summary, location', async () => {
+    expect(await presentCall('edit', { file_path: 'a.txt', old_string: 'foo', new_string: 'bar' })).toEqual({
+      title: 'Edit a.txt', kind: 'edit', rawInput: '"foo" → "bar"', locations: [{ path: 'a.txt' }],
+    })
+  })
+
+  it('edit: clips a long old/new string in the rawInput summary', async () => {
+    const long = 'a'.repeat(60)
+    const p = await presentCall('edit', { file_path: 'a.txt', old_string: long, new_string: 'b' })
+    expect((p as { rawInput: string }).rawInput).toBe(`${JSON.stringify(`${'a'.repeat(40)}…`)} → ${JSON.stringify('b')}`)
+  })
+})