feat(session): add cross-session references

packages/ui/acp/README.md

@@ -28,7 +28,7 @@ The `initialize` handshake reports a fixed server identity (`agentInfo: { name:
 | `initialize` | static | negotiate `protocolVersion`; advertise baseline prompt capabilities (`text`, plus `resource_link` rendered as text) and `loadSession: true` |
 | `session/new` | `ctx.agents.create({ sessionId, meta:{cwd} })` | creates a new session/agent; N concurrent sessions are allowed, keyed by id; advertises the effective command snapshot; `cwd` must be absolute (it becomes the session's workspace — see Per-session cwd); non-empty `additionalDirectories` and `mcpServers` rejected |
 | `session/load` | `ctx.agents.resume(...)` | reserves the id, verifies the persisted cwd, resumes, replays user, assistant, and tool events, and re-advertises commands |
-| `session/prompt` | `ctx.commands.execute()` or `agent.send()` | a flattened prompt beginning with `/` stays in the direct command plane; ordinary prompts support ACP `text` and `resource_link`; unsupported content and empty prompts are rejected; one request is in flight per session and settles on the owning turn's end, with an error turn rejecting the RPC |
+| `session/prompt` | `ctx.commands.execute()` or `agent.send()` | a flattened prompt beginning with `/` stays in the direct command plane; ordinary prompts support ACP `text` and `resource_link`; `dsh-session:` links and inline mentions are snapshotted through optional `ctx.sessionReferences` before enqueue; unsupported content, unavailable reference capability, failed snapshots, and empty prompts are rejected; one request is in flight per session and settles on the owning turn's end, with an error turn rejecting the RPC |
 | `session/cancel` | command `AbortSignal` or `agent.cancel()` | aborts the exact direct command, or applies the queue-aware agent cancel and settles its prompt `cancelled`; one session never cancels another |
 | `session/update` | `session/event` | streams user replay, assistant text/reasoning, retry/failure attempt markers, and tool render intents |
 | `elicitation/create` | `ctx.userInteraction.ask()` | maps `ask_user_question` questions to ACP form elicitations; option descriptions are shown in enum titles, `multi_select` uses ACP array enums, optionless requests use a required `custom` field, and a non-empty custom answer overrides any selected choice |
@@ -37,7 +37,7 @@ The `initialize` handshake reports a fixed server identity (`agentInfo: { name:
 
 ## Multi-session
 
-One id-keyed record map plus exact agent-object checks route every event, prompt, cancel, and approval to one session. Each session permits one in-flight prompt; teardown drains all sessions in parallel. See the [multi-session Agent Note](../../../.agents/notes/implemented/feature/2026-06-14-acp-multi-session.md).
+One id-keyed record map plus exact agent-object checks route every event, prompt, cancel, and approval to one session. Each session permits one in-flight prompt or reference-preparation operation; `session/cancel` aborts preparation before it can enqueue. Teardown drains all sessions in parallel. See the [multi-session Agent Note](../../../.agents/notes/implemented/feature/2026-06-14-acp-multi-session.md).
 
 ## Human commands
 
@@ -104,7 +104,7 @@ The JSON-RPC frames go on stdout, so this plugin MUST run in an example that loa
 
 #### What the model sees
 
-Each ACP `session/prompt` becomes an agent user message: text passes through verbatim and each `resource_link` becomes exactly a leading newline, `[resource_link name=<JSON-string> uri=<JSON-string>]`, and a trailing newline. Unsupported image, audio, and embedded-resource blocks are rejected rather than silently omitted.
+Each ACP `session/prompt` becomes an agent user message: text passes through verbatim and each ordinary `resource_link` becomes exactly a leading newline, `[resource_link name=<JSON-string> uri=<JSON-string>]`, and a trailing newline. When `ctx.sessionReferences` is mounted, a `resource_link` whose URI uses `dsh-session:` or an inline canonical mention becomes readable `@label` text plus one durable untrusted snapshot context; without the capability it is rejected. Unsupported image, audio, and embedded-resource blocks are rejected rather than silently omitted.
 
 #### Token effect
 
@@ -188,6 +188,7 @@ Loading does not rewrite the stored log, but the next request is reconstructed u
 
 - **`additionalDirectories`** — rejected. A session operates in its single `cwd` (see Per-session cwd); widening the tool/filesystem scope to extra roots is a separate sandbox concern, not yet implemented.
 - **Prompt content is `text` + `resource_link` only** — image, audio, and embedded-resource blocks are rejected, as is a non-empty `mcpServers` list at `session/new`.
+- **Session picker UI is client-owned** — the server accepts canonical resource links and inline mentions, but does not add a picker to ACP clients; title/full-text discovery remains future metadata or FTS work.
 - **Terminal cards render completed output** — live incremental streaming and command classification are named follow-ups of [the terminal-rendering Agent Note](../../../.agents/notes/implemented/feature/2026-06-18-acp-terminal-and-tool-rendering.md).
 - **Permission answers are one-shot only** — the bridge offers `allow_once` / `reject_once`; durable `allow_always` grants and their storage/revocation policy remain deferred to the approval seam.
 - **Command output is live-only** — discovery is refreshed after load, but direct command results are not persisted or replayed into a reconnected editor.

packages/ui/acp/package.json

@@ -35,6 +35,7 @@
     "@deepseek-ai/dsh-permission": "^0.0.1",
     "@deepseek-ai/dsh-sandbox": "^0.0.1",
     "@deepseek-ai/dsh-session": "^0.0.1",
+    "@deepseek-ai/dsh-session-reference": "^0.0.1",
     "@deepseek-ai/dsh-session-persistence": "^0.0.1",
     "@deepseek-ai/dsh-system-prompt": "^0.0.1",
     "@deepseek-ai/dsh-tools": "^0.0.1",
@@ -57,6 +58,8 @@
     "@deepseek-ai/dsh-permission": "workspace:^",
     "@deepseek-ai/dsh-sandbox": "workspace:^",
     "@deepseek-ai/dsh-session": "workspace:^",
+    "@deepseek-ai/dsh-session-reference": "workspace:^",
+    "@deepseek-ai/dsh-session-query": "workspace:^",
     "@deepseek-ai/dsh-session-persistence": "workspace:^",
     "@deepseek-ai/dsh-session-persistence-jsonl": "workspace:^",
     "@deepseek-ai/dsh-system-prompt": "workspace:^",

packages/ui/acp/src/codec.ts

@@ -5,6 +5,12 @@
 
 import type { ContentBlock } from '@deepseek-ai/dsh-llm'
 import type { TurnEndReason } from '@deepseek-ai/dsh-session'
+import {
+  SESSION_REFERENCE_SCHEME,
+  decodeSessionReferenceUri,
+  parseSessionReferenceText,
+  type SessionReferenceInput,
+} from '@deepseek-ai/dsh-session-reference'
 import type { ContentBlock as AcpContentBlock, StopReason } from '@agentclientprotocol/sdk'
 
 /**
@@ -81,6 +87,45 @@ export function acpPromptToText(prompt: readonly AcpContentBlock[]): string {
     .join('')
 }
 
+/** ACP prompt text plus structured session references extracted from text and resource links. */
+export interface AcpReferencedPrompt {
+  /** Readable prompt text with opaque session URIs removed. */
+  text: string
+  /** Structured session references in ACP block and inline appearance order. */
+  references: SessionReferenceInput[]
+}
+
+/**
+ * Extract canonical session references while preserving ordinary ACP resource links.
+ * @param prompt - already-supported ACP prompt blocks.
+ * @returns readable text and structured references.
+ * @throws when any observed `dsh-session:` URI is malformed.
+ */
+export function acpPromptToReferencedPrompt(prompt: readonly AcpContentBlock[]): AcpReferencedPrompt {
+  const references: SessionReferenceInput[] = []
+  const text = prompt.flatMap((block): string[] => {
+    switch (block.type) {
+      case 'text': {
+        const parsed = parseSessionReferenceText(block.text)
+        references.push(...parsed.references)
+        return [parsed.text]
+      }
+      case 'resource_link': {
+        if (!block.uri.startsWith(SESSION_REFERENCE_SCHEME)) {
+          return [`\n[resource_link name=${JSON.stringify(block.name)} uri=${JSON.stringify(block.uri)}]\n`]
+        }
+        const sessionId = decodeSessionReferenceUri(block.uri)
+        const label = block.name === '' ? sessionId : block.name
+        references.push({ sessionId, label })
+        return [`@${label}`]
+      }
+      default:
+        return []
+    }
+  }).join('')
+  return { text, references }
+}
+
 /**
  * Whether an ACP prompt contains content the bridge cannot accept. Baseline ACP
  * requires `text` and `resource_link`; richer inline payloads (`resource`,

packages/ui/acp/src/index.ts

@@ -49,6 +49,7 @@ import { assertNever, CallId } from '@deepseek-ai/dsh-llm'
 import type {} from '@deepseek-ai/dsh-llm-retry'
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import type {} from '@deepseek-ai/dsh-commands'
+import type {} from '@deepseek-ai/dsh-session-reference'
 import { SessionId } from '@deepseek-ai/dsh-session'
 // Side-effect type import: resolves `ctx.get('permission')` to the service.
 import type {} from '@deepseek-ai/dsh-permission'
@@ -72,7 +73,7 @@ import {
   type AskUserQuestionRequest,
 } from '@deepseek-ai/dsh-user-interaction'
 import {
-  acpPromptToText,
+  acpPromptToReferencedPrompt,
   harnessBlockToAcpContent,
   promptHasUnsupportedContent,
   turnEndToStopReason,
@@ -302,6 +303,8 @@ interface SessionRecord {
   } | undefined
   /** Abort owner for a direct slash-command request, mutually exclusive with `inflight`. */
   commandAbort: AbortController | undefined
+  /** Abort owner while referenced sessions are snapshotted before enqueue. */
+  promptPreparation: AbortController | undefined
   /** Last idle switch per knob, anchored before the next prompt assembles. */
   pendingSwitches: { preset?: string }
 }
@@ -765,6 +768,7 @@ export function apply(ctx: Context, config: AcpConfig): void {
           target,
           inflight: undefined,
           commandAbort: undefined,
+          promptPreparation: undefined,
           pendingSwitches: {},
         }
         sessions.set(sessionId, record)
@@ -850,6 +854,7 @@ export function apply(ctx: Context, config: AcpConfig): void {
             target,
             inflight: undefined,
             commandAbort: undefined,
+            promptPreparation: undefined,
             pendingSwitches: {},
           }
           sessions.set(sessionId, record)
@@ -885,13 +890,19 @@ export function apply(ctx: Context, config: AcpConfig): void {
       async prompt(params: PromptRequest): Promise<PromptResponse> {
         assertOpen()
         const rec = requireSession(SessionId(params.sessionId))
-        if (rec.inflight !== undefined || rec.commandAbort !== undefined) {
+        if (rec.inflight !== undefined || rec.commandAbort !== undefined || rec.promptPreparation !== undefined) {
           throw invalidParams('a prompt is already in flight for this session')
         }
         if (promptHasUnsupportedContent(params.prompt)) {
           throw invalidParams('only text and resource_link prompt content is supported; image/audio/embedded resource blocks are rejected rather than silently dropped')
         }
-        const text = acpPromptToText(params.prompt)
+        let referencedPrompt: ReturnType<typeof acpPromptToReferencedPrompt>
+        try {
+          referencedPrompt = acpPromptToReferencedPrompt(params.prompt)
+        } catch (error: unknown) {
+          throw invalidParams(`invalid session reference: ${renderThrown(error)}`)
+        }
+        const { text } = referencedPrompt
         if (text.trim().length === 0) {
           // Reject up front rather than calling send(): an empty prompt would
           // queue no work, no turn would start, and the RPC would hang forever
@@ -944,6 +955,32 @@ export function apply(ctx: Context, config: AcpConfig): void {
             rec.commandAbort = undefined
           }
         }
+        let preparedContent: ContentBlock[] = [{ type: 'text', text }]
+        let preparedContexts: NonNullable<Parameters<Agent['send']>[1]>['contexts'] = []
+        if (referencedPrompt.references.length > 0) {
+          const sessionReferences = ctx.get('sessionReferences')
+          if (sessionReferences === undefined) {
+            throw invalidParams('session reference capability unavailable')
+          }
+          const controller = new AbortController()
+          rec.promptPreparation = controller
+          try {
+            const prepared = await sessionReferences.prepare(
+              rec.agent,
+              preparedContent,
+              referencedPrompt.references,
+              controller.signal,
+            )
+            preparedContent = prepared.content
+            preparedContexts = prepared.contexts
+          } catch (error: unknown) {
+            if (controller.signal.aborted) return { stopReason: 'cancelled' }
+            throw invalidParams(`session reference preparation failed: ${renderThrown(error)}`)
+          } finally {
+            rec.promptPreparation = undefined
+          }
+          assertOpen()
+        }
         // Install the in-flight slot BEFORE send() (send does not synchronously
         // flip status to running; the session/event listener records the turn
         // number and settle/rejects it). Capture the log length now as the
@@ -951,7 +988,7 @@ export function apply(ctx: Context, config: AcpConfig): void {
         // produces an error stop reason).
         const stopReason = await new Promise<StopReason>((resolve, reject) => {
           rec.inflight = { resolve, reject, turn: undefined }
-          rec.agent.send([{ type: 'text', text }])
+          rec.agent.send(preparedContent, { contexts: preparedContexts })
         })
         return { stopReason }
       },
@@ -971,7 +1008,9 @@ export function apply(ctx: Context, config: AcpConfig): void {
         // settle it, because cancel() may drop the turn before any turn/end is
         // emitted, and removing this direct settle would move the RPC's
         // resolution onto a later observer path, changing its timing.
-        if (rec.commandAbort !== undefined) {
+        if (rec.promptPreparation !== undefined) {
+          rec.promptPreparation.abort(new Error('session/cancel'))
+        } else if (rec.commandAbort !== undefined) {
           rec.commandAbort.abort(new Error('session/cancel'))
         } else {
           rec.agent.cancel('session/cancel')
@@ -1092,6 +1131,7 @@ export function apply(ctx: Context, config: AcpConfig): void {
       await Promise.all(recs.map(async (rec) => {
         settlePrompt(rec, 'cancelled')
         rec.commandAbort?.abort(new Error('ACP connection closed'))
+        rec.promptPreparation?.abort(new Error('ACP connection closed'))
         // Per-agent dispose (the AgentHandle disposer): unregister this agent,
         // stop its loop (sets disposed + aborts the in-flight step), await
         // quiescence (the loop exit + final flush), and remove its session — so

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

@@ -1,10 +1,11 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { PROTOCOL_VERSION } from '@agentclientprotocol/sdk'
 import { makeBridgeHarness, textResponse, toolCallResponse, type BridgeHarness } from './harness.ts'
 import { SessionId } from '@deepseek-ai/dsh-session'
+import { encodeSessionReferenceUri, formatSessionReferenceMention } from '@deepseek-ai/dsh-session-reference'
 
 /**
  * End-to-end bridge specs over an in-memory transport: a real
@@ -326,6 +327,97 @@ describe('acp bridge', () => {
     expect(JSON.stringify(user)).toContain('resource_link')
   })
 
+  it('rejects canonical session references when the optional capability is not mounted', async () => {
+    harness = await makeBridgeHarness({ storageDir, script: [] })
+    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
+    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
+    await expect(harness.client.prompt({
+      sessionId,
+      prompt: [{ type: 'resource_link', uri: encodeSessionReferenceUri(SessionId('source')), name: 'source' }],
+    })).rejects.toThrow(/session reference capability unavailable/)
+    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
+  })
+
+  it('reports malformed inline session references at the ACP request boundary', async () => {
+    harness = await makeBridgeHarness({ storageDir, script: [] })
+    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
+    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
+    await expect(harness.client.prompt({
+      sessionId,
+      prompt: [{ type: 'text', text: 'use dsh-session:IiJ' }],
+    })).rejects.toThrow(/invalid session reference/)
+    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
+  })
+
+  it('prepares ACP session resource links and inline mentions before one atomic send', async () => {
+    harness = await makeBridgeHarness({ storageDir, withSessionReferences: true, script: [textResponse('ok')] })
+    const source = harness.ctx.sessions.create(SessionId('source'), { meta: { cwd: '/source' } })
+    source.append('user/message', {
+      content: [{ type: 'text', text: 'source background' }],
+      source: { kind: 'user' },
+    }, { surfaceOp: 'append' })
+    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
+    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
+    const mention = formatSessionReferenceMention({ sessionId: source.id, label: 'source-inline' })
+    const result = await harness.client.prompt({
+      sessionId,
+      prompt: [
+        { type: 'text', text: `use ${mention} and ` },
+        { type: 'resource_link', uri: encodeSessionReferenceUri(source.id), name: 'source-link' },
+      ],
+    })
+    expect(result.stopReason).toBe('end_turn')
+
+    const target = harness.ctx.agents.get(SessionId(sessionId))!.session
+    const user = target.events.find(event => event.type === 'user/message')
+    expect(user?.type === 'user/message' && user.data.content).toEqual([
+      { type: 'text', text: 'use @source-inline and @source-link' },
+    ])
+    const context = target.events.find(event => event.type === 'context/message')
+    expect(context?.type === 'context/message' && context.data.meta).toMatchObject({
+      kind: 'session-reference',
+      references: [{ sessionId: 'source', label: 'source-inline' }],
+    })
+    const request = JSON.stringify(harness.adapter.requests[0]?.messages)
+    expect(request).toContain('untrusted, read-only snapshot')
+    expect(request).toContain('source background')
+  })
+
+  it('rejects a failed referenced-session read before starting a turn', async () => {
+    harness = await makeBridgeHarness({ storageDir, withSessionReferences: true, script: [] })
+    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
+    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
+    await expect(harness.client.prompt({
+      sessionId,
+      prompt: [{ type: 'resource_link', uri: encodeSessionReferenceUri(SessionId('missing')), name: 'missing' }],
+    })).rejects.toThrow(/preparation failed/)
+    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
+  })
+
+  it('cancels reference preparation before a turn is created', async () => {
+    harness = await makeBridgeHarness({ storageDir, withSessionReferences: true, script: [] })
+    const source = harness.ctx.sessions.create(SessionId('source'))
+    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
+    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
+    const prepare = vi.spyOn(harness.ctx.sessionReferences, 'prepare').mockImplementation(
+      (_agent, _content, _references, signal) => new Promise((_resolve, reject) => {
+        if (signal?.aborted === true) {
+          reject(new Error('already aborted'))
+          return
+        }
+        signal?.addEventListener('abort', () => { reject(new Error('aborted')) }, { once: true })
+      }),
+    )
+    const pending = harness.client.prompt({
+      sessionId,
+      prompt: [{ type: 'resource_link', uri: encodeSessionReferenceUri(source.id), name: 'source' }],
+    })
+    await vi.waitFor(() => { expect(prepare).toHaveBeenCalledOnce() })
+    await harness.client.cancel({ sessionId })
+    await expect(pending).resolves.toEqual({ stopReason: 'cancelled' })
+    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
+  })
+
   it('rejects a prompt for an unknown session', async () => {
     harness = await makeBridgeHarness({ storageDir })
     await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })

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

@@ -1,8 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import type { ContentBlock } from '@deepseek-ai/dsh-llm'
 import type { TurnEndReason } from '@deepseek-ai/dsh-session'
+import { SessionId } from '@deepseek-ai/dsh-session'
+import { encodeSessionReferenceUri, formatSessionReferenceMention } from '@deepseek-ai/dsh-session-reference'
 import type { ContentBlock as AcpContentBlock } from '@agentclientprotocol/sdk'
 import {
+  acpPromptToReferencedPrompt,
   acpPromptToText,
   harnessBlockToAcpContent,
   promptHasUnsupportedContent,
@@ -55,6 +58,35 @@ describe('acpPromptToText', () => {
   })
 })
 
+describe('acpPromptToReferencedPrompt', () => {
+  it('extracts resource links and inline mentions while preserving ordinary links', () => {
+    const sessionId = SessionId('source/会话')
+    const prompt: AcpContentBlock[] = [
+      { type: 'text', text: `compare ${formatSessionReferenceMention({ sessionId, label: 'inline' })} with ` },
+      { type: 'resource_link', uri: encodeSessionReferenceUri(sessionId), name: 'linked' },
+      { type: 'resource_link', uri: 'file:///x', name: 'x' },
+    ]
+    expect(acpPromptToReferencedPrompt(prompt)).toEqual({
+      text: 'compare @inline with @linked\n[resource_link name="x" uri="file:///x"]\n',
+      references: [{ sessionId, label: 'inline' }, { sessionId, label: 'linked' }],
+    })
+  })
+
+  it('rejects malformed session resource links', () => {
+    expect(() => acpPromptToReferencedPrompt([
+      { type: 'resource_link', uri: 'dsh-session:%%%', name: 'bad' },
+    ])).toThrow(/invalid session reference URI/)
+  })
+
+  it('uses the decoded id for an empty resource name and ignores unsupported direct inputs', () => {
+    const sessionId = SessionId('source')
+    expect(acpPromptToReferencedPrompt([
+      { type: 'resource_link', uri: encodeSessionReferenceUri(sessionId), name: '' },
+      { type: 'image', mimeType: 'image/png', data: 'AA==' },
+    ])).toEqual({ text: '@source', references: [{ sessionId, label: 'source' }] })
+  })
+})
+
 describe('promptHasUnsupportedContent', () => {
   it('detects image, audio, and embedded resource blocks', () => {
     expect(promptHasUnsupportedContent([{ type: 'image', mimeType: 'image/png', data: 'AA==' }])).toBe(true)

packages/ui/acp/tests/harness.ts

@@ -30,6 +30,8 @@ import {
   type Stream,
 } from '@agentclientprotocol/sdk'
 import UserInteractionService from '@deepseek-ai/dsh-user-interaction'
+import SessionQueryService from '@deepseek-ai/dsh-session-query'
+import SessionReferenceService from '@deepseek-ai/dsh-session-reference'
 import * as ToolAskUser from '@deepseek-ai/dsh-tool-ask-user'
 import * as AcpPlugin from '../src/index.ts'
 import { type AcpConfig } from '../src/index.ts'
@@ -191,6 +193,8 @@ export async function makeBridgeHarness(options: {
    * tool + the bridge's own todo/write→plan mapping, not a stand-in.
    */
   withTodo?: boolean
+  /** Mount exact session reads and cross-session snapshot preparation before ACP. */
+  withSessionReferences?: boolean
   /**
    * Plug the REAL filesystem stack (`dsh-fs-local` + `dsh-fs-policy` +
    * `dsh-tool-fs`) so a test can drive `read`/`write`/`edit` through the bridge
@@ -214,6 +218,10 @@ export async function makeBridgeHarness(options: {
   await ctx.plugin(CommandService)
   await ctx.plugin(AgentLoop, { agents: [] })
   await ctx.plugin(SessionPersistenceJsonl, { root: options.storageDir })
+  if (options.withSessionReferences) {
+    await ctx.plugin(SessionQueryService)
+    await ctx.plugin(SessionReferenceService)
+  }
   await ctx.plugin(UserInteractionService)
   if (options.withAskUser) {
     await ctx.plugin(ToolAskUser)

packages/ui/acp/tsconfig.json

@@ -26,6 +26,9 @@
     {
       "path": "../../core/session"
     },
+    {
+      "path": "../../context/session-reference"
+    },
     {
       "path": "../../core/agent"
     },