@lincyaw/dsh 0.1.0 → 0.2.0-rc.1

package/src/node/service.ts

@@ -1,13 +1,13 @@
-import { spawn } from 'node:child_process'
-import type { ChildProcess } from 'node:child_process'
 import { randomBytes } from 'node:crypto'
-import { realpathSync } from 'node:fs'
 import { createRequire } from 'node:module'
-import { dirname, join, relative, resolve, sep } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { connectPresmiumMcp } from '@lincyaw/mcp/client'
-import type { ListedTool, PresmiumMcpClient } from '@lincyaw/mcp/client'
-import type { DshAgent, DshContext, DshLogger } from './dsh.ts'
+import { dirname, join, resolve } from 'node:path'
+import { errorMessage } from '@lincyaw/kernel'
+import type { DocumentSummary } from '@lincyaw/kernel'
+import { DocumentBindings } from './bindings.ts'
+import type { DshContext, DshLogger } from './dsh-types.ts'
+import { launchWorkspaceServer } from './launch.ts'
+import type { LaunchedProcess } from './launch.ts'
+import { SERVER_ROUTES, WORKSPACE_ROUTES } from './server-routes.ts'
 
 export const name = 'presmium-service'
 
@@ -19,262 +19,113 @@ export interface Config {
 
 export interface Endpoint {
   url: string
-  token: string
+  serviceToken: string
   root: string
 }
 
-export interface WorkspaceDocument {
-  dir: string
-  title: string
-  lang?: string
+/** What the row provides to the other rows as `ctx.presmium`. */
+export interface Presmium {
+  server: WorkspaceServerClient
+  bindings: DocumentBindings
 }
 
-export interface PresmiumSession {
-  id: string
-  document: WorkspaceDocument
-  dir: string
-  client: PresmiumMcpClient
-  tools: ListedTool[]
-}
-
-const START_MS = 180_000
 const DOCUMENTS_MS = 2000
-const WATCHDOG = fileURLToPath(new URL('./watchdog.mjs', import.meta.url))
 
-function presmiumBin(): string {
+/** The `presmium` command of the CLI this package depends on. */
+function cliBin(): string {
   const entry = createRequire(import.meta.url).resolve('@lincyaw/cli')
   return join(dirname(dirname(entry)), 'bin', 'presmium.mjs')
 }
 
-function real(path: string): string {
-  try {
-    return realpathSync(path)
-  } catch {
-    return resolve(path)
-  }
-}
-
-export function documentAt(root: string, dir: string, documents: WorkspaceDocument[]): WorkspaceDocument | undefined {
-  const rel = relative(real(root), real(dir)).split(sep).join('/')
-  if (rel.startsWith('..')) return undefined
-  return documents.find(doc => doc.dir === rel)
-}
-
-function serviceEnv(token: string): NodeJS.ProcessEnv {
-  const env: NodeJS.ProcessEnv = {}
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key.startsWith('DSH_') || key.startsWith('DEEPSEEK_') || key === 'NODE_ENV') continue
-    env[key] = value
-  }
-  return { ...env, PRESMIUM_SERVICE_TOKEN: token }
-}
-
-export class PresmiumService {
+/** The workspace server the bundle works with: the one the launcher gives (`url`, `token`), or one it launches itself. */
+export class WorkspaceServerClient {
   readonly ready: Promise<Endpoint>
-  readonly #ctx: DshContext
-  readonly #log: DshLogger
-  #child: ChildProcess | undefined
-  #documents: { at: number, list: Promise<WorkspaceDocument[]> } | undefined
-  readonly #opening = new Map<string, Promise<PresmiumSession | undefined>>()
-  readonly #open = new Map<string, PresmiumSession>()
-  readonly #refreshing = new Map<string, Promise<PresmiumSession | undefined>>()
-  readonly #selectionVersions = new Map<string, number>()
-  readonly #selectionListeners = new Map<string, { before(): Promise<void>, after(): Promise<void> }>()
-  readonly #selected = new Map<string, string | null>()
+  readonly #launched: LaunchedProcess | undefined
+  #documents: { at: number, list: Promise<DocumentSummary[]> } | undefined
   #closed = false
 
-  constructor(ctx: DshContext, config: Config, log: DshLogger) {
-    this.#ctx = ctx
-    this.#log = log
+  constructor(config: Config, log: DshLogger) {
     const root = resolve(config.root || process.cwd())
-    this.ready = config.url
-      ? Promise.resolve({ url: config.url.replace(/\/+$/, ''), token: config.token ?? '', root })
-      : this.#start(root)
-    this.ready.catch((error: unknown) => log.warn(`presmium-service: ${error instanceof Error ? error.message : String(error)}`))
-  }
-
-  #start(root: string): Promise<Endpoint> {
-    const token = randomBytes(24).toString('base64url')
-    const child = spawn(process.execPath, [WATCHDOG, process.execPath, presmiumBin(), 'serve', root, '--port', '0'], {
-      cwd: root,
-      env: serviceEnv(token),
-      stdio: ['pipe', 'pipe', 'pipe'],
-      detached: true,
-    })
-    this.#child = child
-    child.stdin!.on('error', () => {})
-    let output = ''
-    return new Promise<Endpoint>((resolveStart, reject) => {
-      const timer = setTimeout(() => reject(new Error(`presmium serve did not start within ${START_MS / 1000} s:\n${output.slice(-2000)}`)), START_MS)
-      const read = (chunk: Buffer) => {
-        output = (output + chunk.toString()).slice(-20_000)
-        const url = /^serve {2}(http\S+)$/m.exec(output)?.[1]
-        const workspace = /^workspace {2}(.+)$/m.exec(output)?.[1]
-        if (url && workspace) {
-          clearTimeout(timer)
-          resolveStart({ url, token, root: workspace.trim() })
-        }
-      }
-      child.stdout!.on('data', read)
-      child.stderr!.on('data', (chunk: Buffer) => {
-        output = (output + chunk.toString()).slice(-20_000)
-        for (const line of chunk.toString().split('\n').filter(Boolean)) this.#log.debug(`presmium serve: ${line}`)
+    if (config.url) {
+      this.ready = Promise.resolve({ url: config.url.replace(/\/+$/, ''), serviceToken: config.token ?? '', root })
+    } else {
+      const serviceToken = randomBytes(24).toString('base64url')
+      const server = launchWorkspaceServer({
+        presmium: cliBin(),
+        dir: root,
+        serviceToken,
+        onOutput: (text) => {
+          for (const line of text.split('\n').filter(Boolean)) log.debug(`presmium serve: ${line}`)
+        },
       })
-      child.once('exit', (code, signal) => {
-        clearTimeout(timer)
-        if (!this.#closed) this.#log.warn(`presmium serve exited (${signal ?? code})`)
-        reject(new Error(`presmium serve exited (${signal ?? code}):\n${output.slice(-2000)}`))
+      this.#launched = server.process
+      const { child } = server.process
+      void server.process.exited.then(() => {
+        if (!this.#closed) log.warn(`presmium serve exited (${child.signalCode ?? child.exitCode})`)
       })
-    })
+      this.ready = server.ready.then(({ url, root }) => ({ url, serviceToken, root }))
+    }
+    this.ready.catch((error: unknown) => log.warn(`presmium-service: ${errorMessage(error)}`))
   }
 
   async request(path: string, init: { method?: string, body?: unknown, raw?: ArrayBuffer, headers?: Record<string, string>, signal?: AbortSignal } = {}): Promise<Response> {
-    const { url, token } = await this.ready
+    const { url, serviceToken } = await this.ready
     const json = init.body !== undefined
     return fetch(`${url}${path}`, {
       method: init.method ?? (json || init.raw ? 'POST' : 'GET'),
-      headers: { ...json ? { 'Content-Type': 'application/json' } : {}, ...init.headers, ...token ? { Authorization: `Bearer ${token}` } : {} },
+      headers: { ...json ? { 'Content-Type': 'application/json' } : {}, ...init.headers, ...serviceToken ? { Authorization: `Bearer ${serviceToken}` } : {} },
       ...json ? { body: JSON.stringify(init.body) } : init.raw ? { body: init.raw } : {},
       ...init.signal ? { signal: init.signal } : {},
     })
   }
 
-  async #json<T>(path: string, init?: Parameters<PresmiumService['request']>[1]): Promise<T> {
+  async requestJson<T>(path: string, init?: Parameters<WorkspaceServerClient['request']>[1]): Promise<T> {
     const response = await this.request(path, init)
     const text = await response.text()
     if (!response.ok) throw new Error(`${path} answered ${response.status}: ${text}`)
     return JSON.parse(text) as T
   }
 
-  documents(): Promise<WorkspaceDocument[]> {
+  /** A short-lived workspace document list; author mutations invalidate it immediately. */
+  readDocuments(): Promise<DocumentSummary[]> {
     if (!this.#documents || Date.now() - this.#documents.at > DOCUMENTS_MS) {
-      const list = this.#json<{ documents: WorkspaceDocument[] }>('/__presmium/presmium.workspace/documents').then(answer => answer.documents)
+      const list = this.requestJson<{ documents: DocumentSummary[] }>(`${WORKSPACE_ROUTES}documents`).then(answer => answer.documents)
       this.#documents = { at: Date.now(), list }
       list.catch(() => this.#documents = undefined)
     }
     return this.#documents.list
   }
 
-  directoryOf(agent: DshAgent): string {
-    const dirs = this.#ctx.get('workingDirectory') as { get(session: unknown): string } | undefined
-    try {
-      return dirs?.get(agent.session) ?? agent.session.header?.cwd ?? process.cwd()
-    } catch {
-      return agent.session.header?.cwd ?? process.cwd()
-    }
-  }
-
-  attach(agent: DshAgent): Promise<PresmiumSession | undefined> {
-    const id = agent.session.id
-    let known = this.#opening.get(id)
-    if (!known) {
-      known = this.#attach(agent).catch((error: unknown) => {
-        this.#log.warn(`presmium-service: the session ${id} has no Presmium tools: ${error instanceof Error ? error.message : String(error)}`)
-        this.#opening.delete(id)
-        return undefined
-      })
-      this.#opening.set(id, known)
-    }
-    return known
-  }
-
-  async #attach(agent: DshAgent): Promise<PresmiumSession | undefined> {
-    const { root } = await this.ready
-    const id = agent.session.id
-    const documents = await this.documents()
-    const selected = this.#selected.get(id)
-    const document = selected === undefined ? documentAt(root, this.directoryOf(agent), documents) : documents.find(doc => doc.dir === selected)
-    if (!document) return undefined
-    const grant = await this.#json<{ url: string, token: string }>('/__presmium/presmium.server/tokens', { body: { document: document.dir, session: id } })
-    const client = await connectPresmiumMcp(grant.url, grant.token)
-    const session: PresmiumSession = { id, document, dir: resolve(root, document.dir), client, tools: await client.tools() }
-    this.#open.set(id, session)
-    return session
-  }
-
-  async selectDocument(id: string, document: string | null): Promise<void> {
-    if (document !== null && !(await this.documents()).some(doc => doc.dir === document)) throw new Error('Unknown Presmium document')
-    const version = (this.#selectionVersions.get(id) ?? 0) + 1
-    this.#selectionVersions.set(id, version)
-    const listener = this.#selectionListeners.get(id)
-    await listener?.before()
-    if (this.#selectionVersions.get(id) !== version) return
-    this.#selected.set(id, document)
-    await listener?.after()
-  }
-
-  watchSelection(id: string, listener: { before(): Promise<void>, after(): Promise<void> }): () => void {
-    this.#selectionListeners.set(id, listener)
-    return () => { if (this.#selectionListeners.get(id) === listener) this.#selectionListeners.delete(id) }
-  }
-
-  refresh(agent: DshAgent): Promise<PresmiumSession | undefined> {
-    const id = agent.session.id
-    let pending = this.#refreshing.get(id)
-    if (!pending) {
-      pending = this.#refresh(agent).finally(() => this.#refreshing.delete(id))
-      this.#refreshing.set(id, pending)
-    }
-    return pending
-  }
-
-  async #refresh(agent: DshAgent): Promise<PresmiumSession | undefined> {
-    const id = agent.session.id
-    const selected = this.#selected.get(id)
-    const current = await this.attach(agent)
-    if (selected === undefined || current?.document.dir === selected || (!current && selected === null)) return current
-    await this.detach(id, false)
-    return this.attach(agent)
-  }
-
-  session(agent: DshAgent | undefined): PresmiumSession | undefined {
-    return agent ? this.#open.get(agent.session.id) : undefined
-  }
-
-  async detach(id: string, forget = true): Promise<void> {
-    if (forget) {
-      this.#selectionVersions.delete(id)
-      this.#selected.delete(id)
-      this.#selectionListeners.delete(id)
-    }
-    const session = this.#open.get(id)
-    this.#open.delete(id)
-    this.#opening.delete(id)
-    if (!session) return
-    await session.client.close().catch(() => undefined)
-    await this.request('/__presmium/presmium.server/tokens', { method: 'DELETE', body: { session: id } }).then(r => r.body?.cancel(), () => undefined)
-  }
+  /** A successful author operation must be visible before its next context binding. */
+  invalidateDocuments(): void { this.#documents = undefined }
 
+  /** Stops the server it launched, or revokes the session tokens a given server issued to it. */
   async close(): Promise<void> {
     this.#closed = true
-    for (const session of this.#open.values()) await session.client.close().catch(() => undefined)
-    this.#open.clear()
-    this.#opening.clear()
-    this.#selected.clear()
-    this.#selectionVersions.clear()
-    this.#selectionListeners.clear()
-    if (this.#child) {
-      this.#child.kill('SIGTERM')
+    if (this.#launched) {
+      this.#launched.child.kill('SIGTERM')
       return
     }
-    await this.request('/__presmium/presmium.server/tokens', { method: 'DELETE', body: {} }).then(r => r.body?.cancel(), () => undefined)
+    await this.request(`${SERVER_ROUTES}tokens`, { method: 'DELETE', body: {} }).then(r => r.body?.cancel(), () => undefined)
   }
 
+  /** At the host's exit: stops the server it launched, synchronously. */
   stop(): void {
     this.#closed = true
-    if (this.#child?.exitCode === null) this.#child.kill('SIGTERM')
+    if (this.#launched?.child.exitCode === null) this.#launched.child.kill('SIGTERM')
   }
 }
 
 export function apply(ctx: DshContext, config: Config = {}): void {
   const log = ctx.logger?.('presmium') ?? console
-  const service = new PresmiumService(ctx, config, log)
-  ctx.provide('presmium', service)
-  ctx.on('session/disposed', (session: { id: string }) => void service.detach(session.id))
-  const stop = () => service.stop()
+  const server = new WorkspaceServerClient(config, log)
+  const bindings = new DocumentBindings(ctx, server, log)
+  ctx.provide('presmium', { server, bindings } satisfies Presmium)
+  ctx.on('session/disposed', (session: { id: string }) => void bindings.unbind(session.id))
+  const stop = () => server.stop()
   process.once('exit', stop)
   ctx.effect(() => () => {
     process.off('exit', stop)
-    void service.close()
+    void bindings.close().then(() => server.close())
   })
 }

package/src/node/skills.ts

@@ -1,46 +1,24 @@
-import { existsSync, readFileSync } from 'node:fs'
+import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import type { DshContext } from './dsh.ts'
+import { listBundledSkills, skillDirectory } from '@lincyaw/skills'
+import type { DshContext } from './dsh-types.ts'
 
 export const name = 'presmium-skills'
 export const inject = ['skills']
 
-const PACKAGE = fileURLToPath(new URL('../..', import.meta.url))
-
 export function bundledSkills(): string[] {
-  const manifest = JSON.parse(readFileSync(join(PACKAGE, 'package.json'), 'utf8')) as { presmium?: { skills?: string[] } }
-  return manifest.presmium?.skills ?? []
+  return listBundledSkills().map(skill => skill.name)
 }
 
 export function skillDir(skill: string): string | undefined {
-  return [join(PACKAGE, '..', '..', '.agents', 'skills', skill), join(PACKAGE, 'skills', skill)].find(dir => existsSync(join(dir, 'SKILL.md')))
-}
-
-function field(frontmatter: string, key: string): string | undefined {
-  const raw = new RegExp(`^${key}:\\s*(.*)$`, 'm').exec(frontmatter)?.[1]?.trim()
-  if (!raw) return undefined
-  if (raw.startsWith('"')) {
-    try {
-      return JSON.parse(raw) as string
-    } catch {
-      return raw.slice(1, -1)
-    }
-  }
-  return raw.replace(/^'|'$/g, '')
+  try { return skillDirectory(skill) } catch { return undefined }
 }
 
 export function apply(ctx: DshContext): void {
-  for (const skill of bundledSkills()) {
-    const dir = skillDir(skill)
-    if (!dir) {
-      ctx.logger?.('presmium').warn(`presmium-skills: the skill ${skill} is not in this package`)
-      continue
-    }
+  for (const skill of listBundledSkills()) {
+    const dir = skillDirectory(skill.name)
     const path = join(dir, 'SKILL.md')
-    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(readFileSync(path, 'utf8'))
-    const description = match && field(match[1]!, 'description')
-    if (!match || !description) continue
-    ctx.skills.register({ name: field(match[1]!, 'name') ?? skill, description, content: match[2]!, path, source: 'bundled', resourceBase: { kind: 'directory', path: dir } })
+    const content = readFileSync(path, 'utf8').replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '')
+    ctx.skills.register({ name: skill.name, description: skill.description, content, path, source: 'bundled', resourceBase: { kind: 'directory', path: dir } })
   }
 }

package/src/node/telemetry.ts

@@ -0,0 +1,126 @@
+import { randomUUID } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { basename, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { errorMessage } from '@lincyaw/kernel'
+import type { DshContext, DshOtel, DshOtelScalar, DshSessionEvent } from './dsh-types.ts'
+
+export const name = 'presmium-telemetry'
+export const inject = ['otel', 'presmium']
+
+/** The operator's collector: an OTLP/HTTP logs endpoint, its headers (`key=value,…`), and who is using this machine. */
+interface Config {
+  url?: string
+  headers?: string
+  user?: string
+}
+
+/** The page that reports operations: one load of the workbench, in one browser. */
+export interface OperationClient {
+  id: string
+  browser?: string
+  locale?: string
+}
+
+/** One operation of the author in the workbench, as the page records it. */
+export interface OperationRecord {
+  name: string
+  time: number
+  seq: number
+  attributes: Record<string, DshOtelScalar>
+}
+
+/** What the bundle collects for the operator: each session's events and the author's operations in the workbench. */
+export interface PresmiumTelemetry {
+  readonly enabled: boolean
+  operations(client: OperationClient, records: readonly OperationRecord[]): void
+}
+
+const PACKAGE = join(dirname(fileURLToPath(import.meta.url)), '..', '..')
+const SCOPE = { name: '@lincyaw/dsh', version: (JSON.parse(readFileSync(join(PACKAGE, 'package.json'), 'utf8')) as { version: string }).version }
+// A deadline for the queues at the host's exit: what is not sent by then is lost.
+const DRAIN_MS = 3000
+
+/** `key=value,key=value`, values percent-encoded, as in OTEL_EXPORTER_OTLP_HEADERS. */
+export function parseHeaders(text: string | undefined): Record<string, string> {
+  const headers: Record<string, string> = {}
+  for (const pair of (text ?? '').split(',')) {
+    const at = pair.indexOf('=')
+    if (at <= 0) continue
+    headers[pair.slice(0, at).trim().toLowerCase()] = decodeURIComponent(pair.slice(at + 1).trim())
+  }
+  return headers
+}
+
+/** An id of this installation, kept in the state directory, so that its reports can be told apart from another's. */
+function installationId(): string {
+  const file = join(process.env.DSH_HOME ?? join(homedir(), '.presmium'), 'telemetry-installation')
+  try {
+    if (existsSync(file)) return readFileSync(file, 'utf8').trim()
+    mkdirSync(dirname(file), { recursive: true })
+    const id = randomUUID()
+    writeFileSync(file, `${id}\n`)
+    return id
+  } catch {
+    return randomUUID()
+  }
+}
+
+export function apply(ctx: DshContext & { otel: DshOtel }, config: Config = {}): void {
+  if (!config.url) {
+    ctx.provide('presmiumTelemetry', { enabled: false, operations() {} } satisfies PresmiumTelemetry)
+    return
+  }
+  const log = ctx.logger?.('presmium') ?? console
+  const exporter = { url: config.url, headers: parseHeaders(config.headers) }
+  const resourceAttributes = { 'service.name': 'presmium-studio', 'service.version': SCOPE.version, 'presmium.installation.id': installationId(), ...config.user ? { 'user.id': config.user } : {} }
+  const onFailure = (message: string, error?: Error) => log.warn(`presmium-telemetry: ${message}${error ? `: ${errorMessage(error)}` : ''}`)
+  const sessions = ctx.otel.createSessionLogReporter({ exporter, scope: SCOPE, resourceAttributes, onFailure })
+  const operations = ctx.otel.createEventReporter({ exporter, scope: SCOPE, resourceAttributes, onFailure, processor: { scheduledDelayMillis: 1000, maxExportBatchSize: 512 } })
+  let workspace: string | undefined
+  void ctx.presmium.server.ready.then(({ root }) => workspace = basename(root), () => undefined)
+
+  // Every event of every session, whole: the trajectory of the conversation and of each turn of the model.
+  const turns = new Map<string, number>()
+  ctx.on('session/event', (session: { id: string }, event: DshSessionEvent) => {
+    const data = event.data as { turn?: unknown } | undefined
+    if (event.type === 'turn/start' && typeof data?.turn === 'number') turns.set(session.id, data.turn)
+    const turn = turns.get(session.id)
+    const document = ctx.presmium.bindings.documentOf(session.id)
+    sessions.reportSessionLog({
+      sessionId: session.id,
+      event,
+      attributes: { ...workspace ? { 'presmium.workspace': workspace } : {}, ...document === undefined ? {} : { 'presmium.document': document }, ...turn === undefined ? {} : { 'presmium.turn': turn } },
+    })
+  })
+  ctx.on('session/disposed', (session: { id: string }) => void turns.delete(session.id))
+
+  ctx.provide('presmiumTelemetry', {
+    enabled: true,
+    operations(client, records) {
+      for (const record of records) {
+        operations.emit({
+          eventName: `presmium.workbench.${record.name}`,
+          body: record.name,
+          timestamp: record.time,
+          attributes: {
+            ...record.attributes,
+            'presmium.operation': record.name,
+            'presmium.seq': record.seq,
+            'presmium.client.id': client.id,
+            ...client.browser ? { 'presmium.browser.id': client.browser } : {},
+            ...client.locale ? { 'presmium.locale': client.locale } : {},
+            ...workspace ? { 'presmium.workspace': workspace } : {},
+          },
+        })
+      }
+    },
+  } satisfies PresmiumTelemetry)
+  ctx.effect(() => () => {
+    const deadline = AbortSignal.timeout(DRAIN_MS)
+    void operations.shutdown(deadline).catch(() => undefined)
+    const drained = sessions.shutdown().catch(() => undefined)
+    void Promise.race([drained, new Promise(done => setTimeout(done, DRAIN_MS).unref())]).then(() => sessions.stopPending())
+  })
+}

package/src/node/tools.ts

@@ -1,20 +1,20 @@
 import type { ListedTool } from '@lincyaw/mcp/client'
-import type { DshAgent, DshContext, DshToolDefinition } from './dsh.ts'
-import type { PresmiumSession } from './service.ts'
+import type { DshAgent, DshContext, DshToolDefinition } from './dsh-types.ts'
+import type { DocumentBinding } from './bindings.ts'
 
 export const name = 'presmium-tools'
 export const inject = ['presmium', 'tools']
 
 export const PREFIX = 'presmium__'
 
-function definition(session: PresmiumSession, tool: ListedTool): DshToolDefinition {
+function definition(binding: DocumentBinding, tool: ListedTool): DshToolDefinition {
   return {
     name: `${PREFIX}${tool.name}`,
     description: tool.description,
     parameters: tool.inputSchema,
     output: { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: String(value) }] },
     async execute(args, exec) {
-      const result = await session.client.call(tool.name, (args ?? {}) as Record<string, unknown>, exec.signal)
+      const result = await binding.client.call(tool.name, (args ?? {}) as Record<string, unknown>, exec.signal)
       if (result.isError) throw new Error(result.text)
       return result.text
     },
@@ -22,22 +22,45 @@ function definition(session: PresmiumSession, tool: ListedTool): DshToolDefiniti
 }
 
 export function apply(ctx: DshContext): void {
+  const live = new WeakSet<DshAgent>()
   const selections = new WeakMap<DshAgent, () => void>()
-  const registered = new WeakMap<DshAgent, { session?: PresmiumSession, dispose: (() => void)[] }>()
-  const sync = async (agent: DshAgent) => {
-    const session = await ctx.presmium.refresh(agent)
+  const registered = new WeakMap<DshAgent, { binding?: DocumentBinding, tools?: ListedTool[], stop?: () => void, dispose: (() => void)[] }>()
+  const install = (agent: DshAgent, binding: DocumentBinding | undefined) => {
+    if (!live.has(agent) || ctx.presmium.bindings.bindingOf(agent) !== binding) return
     const previous = registered.get(agent)
-    if (previous && previous.session === session) return
+    if (previous && previous.binding === binding && previous.tools === binding?.tools) return
+    previous?.stop?.()
     for (const dispose of previous?.dispose ?? []) dispose()
-    registered.set(agent, { session, dispose: session?.tools.map(tool => agent.ctx.tools.register(definition(session, tool))) ?? [] })
+    registered.set(agent, {
+      binding, tools: binding?.tools,
+      stop: binding?.toolChanges.watch(() => { if (agent.status === 'idle') install(agent, binding) }),
+      dispose: binding?.tools.map(tool => agent.ctx.tools.register(definition(binding, tool))) ?? [],
+    })
+  }
+  const sync = async (agent: DshAgent) => {
+    const binding = await ctx.presmium.bindings.syncBinding(agent)
+    if (binding?.toolChanges.error) await binding.toolChanges.refresh()
+    install(agent, binding)
   }
   ctx.on('agent/created', async ({ agent }: { agent: DshAgent }) => {
+    live.add(agent)
     await sync(agent)
-    selections.set(agent, ctx.presmium.watchSelection(agent.session.id, { before: () => agent.whenIdle(), after: () => sync(agent) }))
+    if (!live.has(agent)) return
+    selections.set(agent, ctx.presmium.bindings.watchSelection(agent.session.id, { before: () => agent.whenIdle(), after: () => sync(agent) }))
+  })
+  ctx.on('agent/disposed', ({ agent }: { agent: DshAgent }) => {
+    live.delete(agent)
+    selections.get(agent)?.(); selections.delete(agent)
+    const previous = registered.get(agent)
+    registered.delete(agent)
+    previous?.stop?.()
+    for (const dispose of previous?.dispose ?? []) dispose()
   })
-  ctx.on('agent/disposed', ({ agent }: { agent: DshAgent }) => { selections.get(agent)?.(); selections.delete(agent) })
   ctx.on('agent/pre-step', async ({ agent }: { agent: DshAgent }, next: () => Promise<unknown>) => {
     await sync(agent)
     return next()
   })
+  ctx.on('agent/status', ({ agent, status }: { agent: DshAgent, status: DshAgent['status'] }) => {
+    if (status === 'idle') install(agent, ctx.presmium.bindings.bindingOf(agent))
+  })
 }