@@ -1,5 +1,6 @@
 import http from 'node:http'
 import net from 'node:net'
+import { EventEmitter } from 'node:events'
 import { PassThrough, type Duplex } from 'node:stream'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
@@ -327,6 +328,60 @@ describe('SystemProxyBridge', () => {
     expect(new URL(restartedUrl).hostname).toBe('127.0.0.1')
   })
 
+  it('waits for the listen callback before closing a pending listener', async () => {
+    const pending = createPendingProxyServer(41001)
+    const createServer = vi.spyOn(http, 'createServer').mockReturnValueOnce(pending.server)
+    const bridge = new SystemProxyBridge(async () => 'DIRECT')
+    bridges.push(bridge)
+    const startup = bridge.start()
+    const startupResult = startup.catch(error => error)
+    const stopping = bridge.stop()
+
+    try {
+      expect(pending.server.listening).toBe(true)
+      expect(pending.server.closeAllConnections).not.toHaveBeenCalled()
+      expect(pending.server.close).not.toHaveBeenCalled()
+      pending.finishListening()
+      await stopping
+      expect(await startupResult).toEqual(new Error('System proxy bridge startup was stopped'))
+      expect(pending.server.close).toHaveBeenCalledTimes(1)
+    } finally {
+      pending.finishListening()
+      await stopping
+      createServer.mockRestore()
+    }
+  })
+
+  it('keeps a newer listener active when an older pending startup is stopped', async () => {
+    const first = createPendingProxyServer(41001)
+    const second = createPendingProxyServer(41002)
+    const createServer = vi.spyOn(http, 'createServer')
+      .mockReturnValueOnce(first.server)
+      .mockReturnValueOnce(second.server)
+    const bridge = new SystemProxyBridge(async () => 'DIRECT')
+    bridges.push(bridge)
+    const firstStartup = bridge.start().catch(error => error)
+    const stopping = bridge.stop()
+    const secondStartup = bridge.start()
+
+    try {
+      second.finishListening()
+      expect(await secondStartup).toBe('http://127.0.0.1:41002')
+      first.finishListening()
+      await stopping
+      expect(await firstStartup).toEqual(new Error('System proxy bridge startup was stopped'))
+      expect(second.server.listening).toBe(true)
+      expect(second.server.closeAllConnections).not.toHaveBeenCalled()
+      expect(second.server.close).not.toHaveBeenCalled()
+      expect(await bridge.start()).toBe('http://127.0.0.1:41002')
+    } finally {
+      first.finishListening()
+      second.finishListening()
+      await stopping
+      createServer.mockRestore()
+    }
+  })
+
   it('closes active CONNECT clients and outbound routes during stop', async () => {
     let acceptTarget!: () => void
     const targetAccepted = new Promise<void>(resolve => { acceptTarget = resolve })
@@ -357,6 +412,33 @@ describe('SystemProxyBridge', () => {
   })
 })
 
+function createPendingProxyServer(port: number) {
+  const server = new EventEmitter() as http.Server
+  let listening = false
+  let listenCallback: (() => void) | undefined
+  Object.defineProperty(server, 'listening', { get: () => listening })
+  server.listen = vi.fn((...args: unknown[]) => {
+    listening = true
+    listenCallback = args.at(-1) as () => void
+    return server
+  }) as typeof server.listen
+  server.close = vi.fn((callback?: () => void) => {
+    listening = false
+    callback?.()
+    return server
+  }) as typeof server.close
+  server.closeAllConnections = vi.fn()
+  server.address = vi.fn(() => ({ address: '127.0.0.1', family: 'IPv4', port }))
+  return {
+    server,
+    finishListening() {
+      const callback = listenCallback
+      listenCallback = undefined
+      callback?.()
+    },
+  }
+}
+
 async function startBridge(
   resolver: (url: string) => Promise<string>,
 ): Promise<string> {
 
@@ -81,15 +81,10 @@ export class SystemProxyBridge implements SystemProxyBridgeLike {
     this.server = null
     for (const socket of this.clientSockets) socket.destroy()
     for (const socket of this.outboundSockets) socket.destroy()
-    // Bun needs the HTTP connection registry drained before close() will
-    // finish after an upgraded CONNECT socket. Calling this before listen
-    // completes breaks the separate startup/stop race, so guard on listening.
-    if (server?.listening) server.closeAllConnections()
-    const closing = server?.listening
-      ? new Promise<void>(resolve => server.close(() => resolve()))
-      : Promise.resolve()
-    await closing
+    // Bun can report listening before its listen callback runs. Closing then
+    // suppresses that callback, so let startup observe cancellation first.
     await startPromise?.catch(() => {})
+    if (server) await closeServer(server)
   }
 
   private async startOnce(generation: number): Promise<string> {
@@ -456,6 +451,9 @@ class SingleSocketAgent extends http.Agent {
 
 function closeServer(server: http.Server): Promise<void> {
   if (!server.listening) return Promise.resolve()
+  // Drain Bun's HTTP connection registry after an upgraded CONNECT socket.
+  // Callers wait for the listen callback before closing the server.
+  server.closeAllConnections()
   return new Promise(resolve => server.close(() => resolve()))
 }
 
 
@@ -7,6 +7,7 @@ import { useMemoryStore } from '../stores/memoryStore'
 import { useSessionStore } from '../stores/sessionStore'
 import { useSettingsStore } from '../stores/settingsStore'
 import { useUIStore } from '../stores/uiStore'
+import type { PreviewLinkTarget } from '@/lib/previewLinkRouter'
 
 const { memoryApiMock } = vi.hoisted(() => ({
   memoryApiMock: {
@@ -21,30 +22,34 @@ vi.mock('../api/memory', () => ({
   memoryApi: memoryApiMock,
 }))
 
-vi.mock('../components/markdown/MarkdownRenderer', () => ({
-  MarkdownRenderer: ({ content, onLinkClick }: { content: string; onLinkClick?: (href: string) => boolean | void }) => {
-    const match = content.match(/\[([^\]]+)\]\(([^)]+)\)/)
-    const linkText = match?.[1]
-    const linkHref = match?.[2]
-    return (
-      <div data-testid="markdown-preview">
-        {content}
-        {linkText && linkHref ? (
-          <a
-            href={linkHref}
-            onClick={(event) => {
-              if (onLinkClick?.(linkHref)) {
-                event.preventDefault()
-              }
-            }}
-          >
-            {linkText}
-          </a>
-        ) : null}
-      </div>
-    )
-  },
-}))
+vi.mock('../components/markdown/MarkdownRenderer', async () => {
+  const { classifyPreviewLink } = await import('@/lib/previewLinkRouter')
+  return {
+    MarkdownRenderer: ({ content, onLinkClick }: { content: string; onLinkClick?: (href: PreviewLinkTarget) => boolean | void }) => {
+      const match = content.match(/\[([^\]]+)\]\(([^)]+)\)/)
+      const linkText = match?.[1]
+      const linkHref = match?.[2]
+      return (
+        <div data-testid="markdown-preview">
+          {content}
+          {linkText && linkHref ? (
+            <a
+              href={linkHref}
+              onClick={(event) => {
+                const parsed = classifyPreviewLink(linkHref)
+                if (onLinkClick?.(parsed.path ? { path: parsed.path } : linkHref)) {
+                  event.preventDefault()
+                }
+              }}
+            >
+              {linkText}
+            </a>
+          ) : null}
+        </div>
+      )
+    },
+  }
+})
 
 describe('MemorySettings', () => {
   beforeEach(() => {
@@ -487,7 +492,8 @@ describe('MemorySettings', () => {
     expect(screen.queryByLabelText('Editor')).not.toBeInTheDocument()
   })
 
-  it('opens linked memory markdown files from the rendered preview', async () => {
+  it.each(['notes/manual.md', 'notes/literal%20name.md', 'notes/name#hash.md'])(
+    'opens linked memory markdown file %s from the parsed preview', async (targetPath) => {
     memoryApiMock.listFiles.mockResolvedValue({
       files: [
         {
@@ -501,7 +507,7 @@ describe('MemorySettings', () => {
           isIndex: true,
         },
         {
-          path: 'notes/manual.md',
+          path: targetPath,
           name: 'manual.md',
           title: 'Manual',
           bytes: 24,
@@ -514,9 +520,9 @@ describe('MemorySettings', () => {
     memoryApiMock.readFile.mockImplementation((_projectId: string, path: string) => Promise.resolve({
       file: {
         path,
-        content: path === 'notes/manual.md'
+        content: path !== 'MEMORY.md'
           ? '# Manual\n'
-          : '# Project Memory\n\n- [Manual](notes/manual.md)\n',
+          : `# Project Memory\n\n- [Manual](${targetPath.split('/').map(encodeURIComponent).join('/')})\n`,
         updatedAt: '2026-05-01T00:00:00.000Z',
         bytes: 48,
       },
@@ -527,7 +533,7 @@ describe('MemorySettings', () => {
     fireEvent.click(await screen.findByRole('link', { name: 'Manual' }))
 
     await waitFor(() => {
-      expect(memoryApiMock.readFile).toHaveBeenCalledWith('-workspace-demo', 'notes/manual.md')
+      expect(memoryApiMock.readFile).toHaveBeenCalledWith('-workspace-demo', targetPath)
     })
     expect(await screen.findByTestId('markdown-preview')).toHaveTextContent('Manual')
     expect(screen.queryByLabelText('Editor')).not.toBeInTheDocument()
 
@@ -106,6 +106,79 @@ afterEach(() => {
 })
 
 describe('AssistantMessage file references', () => {
+  it.each([
+    ['[open](/work/My%20Notes.md)', '/work/My Notes.md'],
+    ['[open](/work/literal%2520name.md)', '/work/literal%20name.md'],
+    ['输出目录：`/other/QA%20root`\n[open](My%20Notes.md)', '/other/QA%20root/My Notes.md'],
+  ])('opens the reconciled card and prose at the same parsed file for %s', async (content, path) => {
+    // The server confirms only the actual disk path, so an encoded URI cannot
+    // accidentally get a card just because a permissive mock says it exists.
+    statWorkspaceFiles.mockImplementation(async (_sessionId: string, paths: string[]) => ({
+      files: paths.map((candidate) => ({
+        path: candidate, state: candidate === path ? 'file' : 'missing', mtimeMs: Date.now(),
+      })),
+    }))
+    const view = render(<AssistantMessage
+      sessionId="s1" content={content} turnChangedFiles={[]} turnOutputEvidence={shellTurn}
+    />)
+    fireEvent.click(await screen.findByRole('button', { name: 'assistantOutputs.openAria' }))
+    await waitFor(() => expect(openPreviewFn).toHaveBeenCalledWith('s1', path, {}))
+    openPreviewFn.mockClear()
+    fireEvent.click(screen.getByRole('link', { name: 'open' }))
+    await waitFor(() => expect(openPreviewFn).toHaveBeenCalledWith('s1', path, {}))
+    view.unmount()
+    resetWorkspaceFileStatsForTests()
+    resetDiskListingCacheForTests()
+    openPreviewFn.mockClear()
+
+    // The exact changed-file match must keep the card when no unseen writes
+    // can explain an unmatched output.
+    render(<AssistantMessage
+      sessionId="s1" content={content} turnChangedFiles={[path]} turnOutputEvidence={{ unlistedWrites: false }}
+    />)
+    fireEvent.click(await screen.findByRole('button', { name: 'assistantOutputs.openAria' }))
+    await waitFor(() => expect(openPreviewFn).toHaveBeenCalledWith('s1', path, {}))
+  })
+
+  // Native QA: the renderer had decoded the Markdown destination into data-file-path,
+  // then the click router decoded that filesystem path a second time.
+  it.each([
+    ['[open](docs/literal%2520name.md)', 'docs/literal%20name.md', {}],
+    ['[open](/work/literal%2525name.md:7:3)', '/work/literal%25name.md', { line: 7, column: 3 }],
+    ['[open](C:/QA/literal%2523name.md#L9)', 'C:/QA/literal%23name.md', { line: 9 }],
+    ['[open](file:///work/literal%252Fname.md)', '/work/literal%2Fname.md', {}],
+    ['[open](docs/My%20Notes.md:3)', 'docs/My Notes.md', { line: 3 }],
+    ['[open](file:///work/My%20Notes.md)', '/work/My Notes.md', {}],
+    ['[open](file:///C:/QA/My%20Notes.md#L9)', 'C:/QA/My Notes.md', { line: 9 }],
+    ['[open](docs/name%23hash.md#L2)', 'docs/name#hash.md', { line: 2 }],
+    ['[open](docs/100%.md)', 'docs/100%.md', {}],
+  ])('opens the exact disk path from rendered Markdown %s', async (content, path, reveal) => {
+    render(<AssistantMessage sessionId="s1" content={content} />)
+    fireEvent.click(screen.getByRole('link', { name: 'open' }))
+    await waitFor(() => expect(openPreviewFn).toHaveBeenCalledWith('s1', path, reveal))
+    expect(statWorkspaceFiles).toHaveBeenCalledWith('s1', expect.arrayContaining([path]))
+  })
+
+  it.each(['%20', '%25', '%23', '%2F'])(
+    'opens literal %s names in bare and inline-code references under the declared root', async (percent) => {
+      const path = `docs/literal${percent}name.md`
+      const content = `输出目录：\`/work/QA%20root\`\n\n${path}:7\n\n\`${path}:9:3\``
+      render(<AssistantMessage sessionId="s1" content={content} />)
+      fireEvent.click(await screen.findByRole('link', { name: `${path}:7` }))
+      expect(openPreviewFn).toHaveBeenCalledWith('s1', `/work/QA%20root/${path}`, { line: 7 })
+      fireEvent.click(await screen.findByRole('link', { name: `${path}:9:3` }))
+      expect(openPreviewFn).toHaveBeenCalledWith('s1', `/work/QA%20root/${path}`, { line: 9, column: 3 })
+    },
+  )
+
+  it('uses the same literal percent filename in a Markdown context menu', async () => {
+    render(<AssistantMessage sessionId="s1" content={'[open](docs/literal%2520name.md:7)'} />)
+    fireEvent.contextMenu(screen.getByRole('link', { name: 'open' }))
+    await waitFor(() => expect(getTargetsForPath).toHaveBeenCalledWith('/work/docs/literal%20name.md'))
+    fireEvent.click(await screen.findByRole('menuitem', { name: 'openWith.copyPath' }))
+    expect(copyTextToClipboard).toHaveBeenCalledWith('/work/docs/literal%20name.md')
+  })
+
   it('opens the code view at the referenced line', async () => {
     // #1146, and the contract src/constants/prompts.ts already asks the model for.
     render(<AssistantMessage sessionId="s1" content={'越界在 desktop/src/lib/foo.ts:42'} isStreaming={false} />)
 
@@ -25,6 +25,7 @@ import { useTranslation, type TranslationKey } from '../../i18n'
 import { useDiskConfirmedTargets } from '../../hooks/useDiskConfirmedTargets'
 import { useTurnWrittenTargets } from '../../hooks/useTurnWrittenTargets'
 import { createWorkspaceFileLinkVerifier } from '../../lib/workspaceFileStats'
+import type { PreviewLinkTarget } from '@/lib/previewLinkRouter'
 
 type Props = {
   content: string
@@ -64,7 +65,7 @@ export const AssistantMessage = memo(function AssistantMessage({
   const [viewer, setViewer] = useState<{ images: Array<{ src: string; name: string; path?: string }>; index: number } | null>(null)
 
   const handleLinkClick = useCallback(
-    (href: string, event: ReactMouseEvent<HTMLDivElement>): boolean => {
+    (href: PreviewLinkTarget, event: ReactMouseEvent<HTMLDivElement>): boolean => {
       if (!sessionId) return false
       const handled = openPreviewLink(resolveAssistantFileHref(href, content), sessionId)
       if (handled) event.preventDefault()
 
@@ -101,6 +101,15 @@ afterEach(() => {
 })
 
 describe('AssistantOutputTargetCard', () => {
+  it.each(['%20', '%25', '%23', '%2F'])(
+    'opens a written file with a literal %s in its filename', async (percent) => {
+      const path = `docs/literal${percent}name.md`
+      render(<AssistantOutputTargetCard target={{ ...markdownTarget, href: path, normalizedPath: path, source: 'changed-file' }} sessionId="s1" />)
+      fireEvent.click(screen.getByLabelText('assistantOutputs.open'))
+      await waitFor(() => expect(openPreviewFn).toHaveBeenCalledWith('s1', path, {}))
+    },
+  )
+
   it('renders a markdown target title + Markdown badge', () => {
     render(<AssistantOutputTargetCard target={markdownTarget} sessionId="s1" />)
     expect(screen.getByText('readme.md')).toBeInTheDocument()
 
@@ -12,6 +12,7 @@ import { describeFileType, type OpenWithItem } from '../../lib/openWithItems'
 import { buildOpenWithMenuItemsForHref } from '../../lib/openWithMenuItems'
 import { openPreviewLink } from '../../lib/openPreviewLink'
 import { reportOpenFailure } from '../../lib/systemFileOpen'
+import type { PreviewLinkTarget } from '@/lib/previewLinkRouter'
 
 type Props = {
   target: AssistantOutputTarget
@@ -24,6 +25,10 @@ export function AssistantOutputTargetCard({ target, sessionId, workDir }: Props)
   const [openWith, setOpenWith] = useState<{ items: OpenWithItem[]; anchor: DOMRect; triggerEl: HTMLElement } | null>(null)
 
   const isLocalhost = target.kind === 'localhost-url'
+  // normalizedPath is a disk path, even when the authored href was encoded.
+  const linkTarget: PreviewLinkTarget = isLocalhost
+    ? target.href
+    : { path: target.normalizedPath ?? target.href }
   const typeInfo = describeFileType(target.normalizedPath ?? target.href)
   const badge = isLocalhost
     ? t('assistantOutputs.kind.localhost')
@@ -41,8 +46,8 @@ export function AssistantOutputTargetCard({ target, sessionId, workDir }: Props)
     event.stopPropagation()
     // A card is only shown for something it can open; one the router cannot
     // place must say so rather than leave the click looking dead (#1556).
-    if (!openPreviewLink(target.href, sessionId)) reportOpenFailure(target.href)
-  }, [sessionId, target.href])
+    if (!openPreviewLink(linkTarget, sessionId)) reportOpenFailure(target.href)
+  }, [sessionId, linkTarget, target.href])
 
   const handleOpenWith = useCallback((event: ReactMouseEvent<HTMLButtonElement>) => {
     event.stopPropagation()
@@ -56,15 +61,15 @@ export function AssistantOutputTargetCard({ target, sessionId, workDir }: Props)
     const triggerEl = event.currentTarget
     const rect = triggerEl.getBoundingClientRect()
     void (async () => {
-      const items = await buildOpenWithMenuItemsForHref(target.href, {
+      const items = await buildOpenWithMenuItemsForHref(linkTarget, {
         sessionId,
         workDir,
         t: (k, v) => t(k as TranslationKey, v),
       })
       if (items.length === 0) return
       setOpenWith({ items, anchor: rect, triggerEl })
     })()
-  }, [openWith, sessionId, t, target.href, workDir])
+  }, [openWith, sessionId, t, linkTarget, workDir])
 
   return (
     <section className="flex items-stretch overflow-hidden rounded-[var(--radius-lg)] border border-[var(--color-border)] bg-[var(--color-surface-container-lowest)]">