@lincyaw/dsh 0.1.0 → 0.2.0-rc.1

package/src/node/{turns/index.ts → turns.ts}

@@ -1,13 +1,20 @@
 import { randomUUID } from 'node:crypto'
-import type { DshAgent, DshContext, DshToolExecution } from '../dsh.ts'
-import type { PresmiumSession } from '../service.ts'
+import { errorMessage } from '@lincyaw/kernel'
+import { isInside } from '@lincyaw/kernel/node'
+import type { DshAgent, DshContext, DshToolExecution } from './dsh-types.ts'
+import { WORKSPACE_ROUTES } from './server-routes.ts'
+
+// What a writing tool answers when the change cannot be recorded. The AI reads it and tells the author in their own
+// language, so it names what the author sees (Version History) and none of the internals behind it.
+const NOT_RECORDED = 'Version History is not turned on for this folder, so the change could not be recorded for the author to review. Tell the author to ask their administrator to turn on Version History for this folder.'
+const NOTHING_CHANGED = 'Nothing was changed.'
 
 export const name = 'presmium-turns'
 export const inject = ['presmium', 'tools']
 
-export const WRITES = new Set(['write', 'edit', 'str_replace_editor', 'bash', 'pwsh', 'terminal_send'])
+export const WRITING_TOOLS = new Set(['write', 'edit', 'str_replace_editor', 'bash', 'pwsh', 'terminal_send'])
 
-const REVIEW = '/__presmium/presmium.workspace/review'
+const REVIEW = `${WORKSPACE_ROUTES}review`
 const RETRY_MS = 2000
 
 interface LiveAgent extends DshAgent {
@@ -29,9 +36,10 @@ interface Reverted {
   files: string[]
 }
 
-interface Turns {
+/** The turn an agent session is in, and whether a tool wrote in it (to which document's review). */
+interface TurnState {
   turn?: number
-  document?: PresmiumSession
+  document?: string
   wrote: boolean
 }
 
@@ -52,26 +60,27 @@ export function revertNotice(event: Reverted): unknown {
 
 export function apply(ctx: DshContext): void {
   const log = ctx.logger?.('presmium') ?? console
-  const sessions = new Map<string, Turns>()
+  const turnStates = new Map<string, TurnState>()
   const agents = new Map<string, LiveAgent>()
   const pending = new Map<string, unknown[]>()
-  const turnsOf = (id: string) => {
-    let known = sessions.get(id)
-    if (!known) sessions.set(id, known = { wrote: false })
+  const turnStateOf = (id: string) => {
+    let known = turnStates.get(id)
+    if (!known) turnStates.set(id, known = { wrote: false })
     return known
   }
   const parents = new Map<string, string>()
-  const reviewerOf = (id: string) => {
+  /** A subagent's writes go to the review of the session that started it. */
+  const rootAgentSessionOf = (id: string) => {
     let at = id
     for (let depth = 0; depth < 32 && parents.has(at); depth++) at = parents.get(at)!
     return at
   }
 
-  const post = async (presmium: PresmiumSession, session: string, path: string, body: Record<string, unknown>): Promise<void> => {
-    const response = await ctx.presmium.request(`${REVIEW}/${path}`, { body: { session, ...body }, headers: { 'presmium-document': encodeURIComponent(presmium.document.dir) } })
+  const postReview = async (document: string, agentSessionId: string, path: string, body: Record<string, unknown>): Promise<void> => {
+    const response = await ctx.presmium.server.request(`${REVIEW}/${path}`, { body: { session: agentSessionId, ...body }, headers: { 'presmium-document': encodeURIComponent(document) } })
     const text = await response.text()
     if (response.ok) return
-    if (path === 'open' && response.status === 404) throw new Error('the workspace is not a git repository, so the author cannot review a change: run git init in it')
+    if (path === 'open' && response.status === 404) throw new Error(NOT_RECORDED)
     let reason = text
     try {
       reason = (JSON.parse(text) as { error?: string, detail?: string }).error ?? reason
@@ -81,32 +90,34 @@ export function apply(ctx: DshContext): void {
   }
 
   ctx.on('session/event', (session: { id: string }, event: SessionEvent) => {
-    if (event.type === 'turn/start' && typeof event.data?.turn === 'number') turnsOf(session.id).turn = event.data.turn
+    if (event.type === 'turn/start' && typeof event.data?.turn === 'number') turnStateOf(session.id).turn = event.data.turn
     if (event.type !== 'turn/end') return
-    const turns = sessions.get(session.id)
-    if (!turns?.wrote || !turns.document) return
-    turns.wrote = false
-    void post(turns.document, session.id, 'step', { ...turns.turn !== undefined ? { turn: turns.turn } : {}, end: true })
-      .catch((error: unknown) => log.warn(`presmium-turns: the end of turn ${turns.turn} of ${session.id} was not told to the review: ${error instanceof Error ? error.message : String(error)}`))
+    const state = turnStates.get(session.id)
+    if (!state?.wrote || state.document === undefined) return
+    state.wrote = false
+    void postReview(state.document, session.id, 'step', { ...state.turn !== undefined ? { turn: state.turn } : {}, end: true })
+      .catch((error: unknown) => log.warn(`presmium-turns: the end of turn ${state.turn} of ${session.id} was not told to the review: ${errorMessage(error)}`))
   })
 
   ctx.on('tools/execute', async (exec: DshToolExecution, next: () => Promise<unknown>) => {
-    const presmium = WRITES.has(exec.name) ? ctx.presmium.session(exec.agent) : undefined
-    if (!presmium) return next()
-    const session = reviewerOf(presmium.id)
-    const turns = turnsOf(session)
+    if (!WRITING_TOOLS.has(exec.name) || !exec.agent) return next()
+    const { root } = await ctx.presmium.server.ready
+    if (!isInside(ctx.presmium.bindings.workingDirectoryOf(exec.agent), root)) return next()
+    const document = ctx.presmium.bindings.bindingOf(exec.agent)?.document.dir ?? ''
+    const agentSessionId = rootAgentSessionOf(exec.agent.session.id)
+    const state = turnStateOf(agentSessionId)
     try {
-      await post(presmium, session, 'open', turns.turn !== undefined ? { turn: turns.turn } : {})
+      await postReview(document, agentSessionId, 'open', state.turn !== undefined ? { turn: state.turn } : {})
     } catch (error) {
-      throw new Error(`Presmium: ${error instanceof Error ? error.message : String(error)}. Nothing was changed.`)
+      throw new Error(`${errorMessage(error)} ${NOTHING_CHANGED}`)
     }
-    turns.document = presmium
-    turns.wrote = true
+    state.document = document
+    state.wrote = true
     try {
       return await next()
     } finally {
-      await post(presmium, session, 'step', { ...turns.turn !== undefined ? { turn: turns.turn } : {}, label: labelOf(exec), tool: exec.name })
-        .catch((error: unknown) => log.warn(`presmium-turns: no checkpoint after ${exec.name} in ${session}: ${error instanceof Error ? error.message : String(error)}`))
+      await postReview(document, agentSessionId, 'step', { ...state.turn !== undefined ? { turn: state.turn } : {}, label: labelOf(exec), tool: exec.name })
+        .catch((error: unknown) => log.warn(`presmium-turns: no checkpoint after ${exec.name} in ${agentSessionId}: ${errorMessage(error)}`))
     }
   })
 
@@ -121,11 +132,11 @@ export function apply(ctx: DshContext): void {
     if (agents.get(agent.session.id) === agent) agents.delete(agent.session.id)
   })
   ctx.on('session/disposed', (session: { id: string }) => {
-    sessions.delete(session.id)
+    turnStates.delete(session.id)
     parents.delete(session.id)
   })
 
-  const tell = (event: Reverted) => {
+  const injectRevertNotice = (event: Reverted) => {
     const notice = revertNotice(event)
     const agent = agents.get(event.session)
     if (agent) agent.inject(notice)
@@ -134,10 +145,10 @@ export function apply(ctx: DshContext): void {
   }
 
   const stop = new AbortController()
-  const follow = async () => {
+  const subscribeReviewEvents = async () => {
     while (!stop.signal.aborted) {
       try {
-        const response = await ctx.presmium.request(`${REVIEW}/events`, { headers: { accept: 'text/event-stream' }, signal: stop.signal })
+        const response = await ctx.presmium.server.request(`${REVIEW}/events`, { headers: { accept: 'text/event-stream' }, signal: stop.signal })
         if (!response.ok || !response.body) throw new Error(`review/events answered ${response.status}`)
         const decoder = new TextDecoder()
         let buffer = ''
@@ -150,16 +161,16 @@ export function apply(ctx: DshContext): void {
             const data = block.split('\n').filter(line => line.startsWith('data: ')).map(line => line.slice(6)).join('\n')
             if (!data) continue
             const event = JSON.parse(data) as { type?: string }
-            if (event.type === 'reverted') tell(event as Reverted)
+            if (event.type === 'reverted') injectRevertNotice(event as Reverted)
           }
         }
       } catch (error) {
         if (stop.signal.aborted) return
-        log.debug(`presmium-turns: the review events: ${error instanceof Error ? error.message : String(error)}`)
+        log.debug(`presmium-turns: the review events: ${errorMessage(error)}`)
       }
       await new Promise(done => setTimeout(done, RETRY_MS).unref())
     }
   }
-  void follow()
+  void subscribeReviewEvents()
   ctx.effect(() => () => stop.abort())
 }

package/src/node/workbench.ts

@@ -1,7 +1,9 @@
-import type { DshContext } from './dsh.ts'
+import { LOCAL_AUTHOR } from '@lincyaw/kernel'
+import type { DshContext, DshOtelScalar } from './dsh-types.ts'
+import type { OperationClient, OperationRecord, PresmiumTelemetry } from './telemetry.ts'
 
 export const name = 'presmium-workbench'
-export const inject = ['presmium', 'connection', 'webServer']
+export const inject = ['presmium', 'connection', 'webServer', 'presmiumTelemetry']
 
 const ICON = `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="7" fill="#0F5F5C"/><path d="M11 8h7.5a6.5 6.5 0 0 1 0 13H15v4h-4zM15 12v5h3.5a2.5 2.5 0 0 0 0-5z" fill="#F7F5F0" fill-rule="evenodd"/></svg>')}`
 
@@ -16,7 +18,35 @@ interface WebServer {
   tapIndex(transform: (html: string) => string): () => void
 }
 
-export function apply(ctx: DshContext & { webServer: WebServer }): void {
+const OPERATION = /^[a-z][a-z0-9.-]{0,63}$/
+const RECORDS = 500
+const ATTRIBUTES = 64
+const TEXT = 100_000
+
+const text = (value: unknown, limit: number): string | undefined => (typeof value === 'string' && value ? value.slice(0, limit) : undefined)
+
+/** The page's report of the author's operations, kept to names, times and scalar attributes of bounded size. */
+export function readOperations(body: unknown): { client: OperationClient, records: OperationRecord[] } | undefined {
+  if (!body || typeof body !== 'object') return undefined
+  const { client, records } = body as { client?: Record<string, unknown>, records?: unknown }
+  const id = text(client?.id, 64)
+  if (!id || !Array.isArray(records) || records.length > RECORDS) return undefined
+  const read: OperationRecord[] = []
+  for (const record of records as Record<string, unknown>[]) {
+    if (!record || typeof record.name !== 'string' || !OPERATION.test(record.name) || typeof record.time !== 'number' || typeof record.seq !== 'number') return undefined
+    const attributes: Record<string, DshOtelScalar> = {}
+    for (const [key, value] of Object.entries(record.attributes ?? {}).slice(0, ATTRIBUTES)) {
+      if (typeof value === 'string') attributes[key.slice(0, 128)] = value.slice(0, TEXT)
+      else if ((typeof value === 'number' && Number.isFinite(value)) || typeof value === 'boolean') attributes[key.slice(0, 128)] = value
+    }
+    read.push({ name: record.name, time: record.time, seq: record.seq, attributes })
+  }
+  const browser = text(client?.browser, 64)
+  const locale = text(client?.locale, 32)
+  return { client: { id, ...browser ? { browser } : {}, ...locale ? { locale } : {} }, records: read }
+}
+
+export function apply(ctx: DshContext & { webServer: WebServer, presmiumTelemetry: PresmiumTelemetry }): void {
   ctx.effect(() => ctx.webServer.tapIndex(brandIndex))
   ctx.connection.fetch.register({
     path: '/api/presmium/context', methods: ['POST'], requestBody: 'buffered',
@@ -24,20 +54,35 @@ export function apply(ctx: DshContext & { webServer: WebServer }): void {
       const body = await request.json().catch(() => null) as { session?: unknown, document?: unknown } | null
       if (!body || typeof body.session !== 'string' || !body.session || (body.document !== null && typeof body.document !== 'string')) return new Response('Invalid context', { status: 400 })
       try {
-        await ctx.presmium.selectDocument(body.session, body.document)
+        await ctx.presmium.bindings.selectDocument(body.session, body.document)
         return Response.json({ session: body.session, document: body.document })
       } catch {
         return new Response('Unknown document', { status: 400 })
       }
     },
   })
+  // The workbench's operations, for the operator's collector: the page learns whether to record them, then sends them in batches.
+  ctx.connection.fetch.register({
+    path: '/api/presmium/telemetry',
+    methods: ['GET', 'POST'],
+    requestBody: 'buffered',
+    async fetch(request) {
+      const telemetry = ctx.presmiumTelemetry
+      if (request.method === 'GET') return Response.json({ enabled: telemetry.enabled })
+      if (!telemetry.enabled) return new Response(null, { status: 204 })
+      const read = readOperations(await request.json().catch(() => null))
+      if (!read) return new Response('Invalid operations', { status: 400 })
+      telemetry.operations(read.client, read.records)
+      return new Response(null, { status: 204 })
+    },
+  })
   ctx.connection.fetch.register({
     path: '/api/presmium/workbench',
     methods: ['GET'],
     requestBody: 'buffered',
     async fetch() {
-      const { url, root } = await ctx.presmium.ready
-      return new Response(JSON.stringify({ mcp: `${url}/mcp`, root }), { headers: { 'Content-Type': 'application/json' } })
+      const { url, root } = await ctx.presmium.server.ready
+      return new Response(JSON.stringify({ mcp: `${url}/mcp`, root, member: LOCAL_AUTHOR }), { headers: { 'Content-Type': 'application/json' } })
     },
   })
 }

package/src/node/workspace-events.ts

@@ -0,0 +1,167 @@
+import type { IncomingMessage } from 'node:http'
+import type { Duplex } from 'node:stream'
+import { EventSource } from 'eventsource'
+import { WebSocketServer, WebSocket } from 'ws'
+import { AUTHORING_CLIENT_EVENT_MAX_BYTES } from '@lincyaw/kernel'
+import type { AuthoringClientLease, AuthoringClientEvent } from '@lincyaw/kernel'
+import { validateAuthoringClientLease } from '@lincyaw/kernel/node'
+import type { DshContext } from './dsh-types.ts'
+import { SERVER_ROUTES, WORKSPACE_ROUTES } from './server-routes.ts'
+import { WORKSPACE_EVENTS_PATH, workspaceEventCommand } from '../workspace-events.ts'
+import type { WorkspaceEventMessage } from '../workspace-events.ts'
+
+export const name = 'presmium-events'
+export const inject = ['presmium', 'connection', 'webServer']
+
+/** The documented WebServer upgrade and Connection admission faces. */
+interface EventContext extends DshContext {
+  webServer: { registerUpgrade(route: { path: string, handler(request: IncomingMessage, socket: Duplex, head: Buffer): void }): () => void }
+  connection: DshContext['connection'] & {
+    admit(request: IncomingMessage): { rejection: 401 | 403 } | { peer: { principal: { kind: string }, signal: AbortSignal } }
+  }
+}
+
+const ROUTES = {
+  document: { path: `${WORKSPACE_ROUTES}document/events`, event: 'document' },
+  diagnostics: { path: `${SERVER_ROUTES}diagnostics/events`, event: 'diagnostics' },
+  review: { path: `${WORKSPACE_ROUTES}review`, event: 'review' },
+  ir: { path: `${WORKSPACE_ROUTES}ir/events`, event: 'revision' },
+  jobs: { path: `${WORKSPACE_ROUTES}jobs/events`, event: 'job' },
+} as const
+const MAX_SUBSCRIPTIONS = 16
+const MAX_BUFFERED_BYTES = 2 << 20
+
+/** Borrow the framework listener and trust fence; never take ownership of their server or Peer. */
+export function apply(ctx: EventContext): void {
+  const server = new WebSocketServer({ noServer: true, maxPayload: AUTHORING_CLIENT_EVENT_MAX_BYTES, perMessageDeflate: false })
+  const sockets = new Map<WebSocket, () => void>()
+  const unregister = ctx.webServer.registerUpgrade({
+    path: WORKSPACE_EVENTS_PATH,
+    handler(request, socket, head) {
+      const admission = ctx.connection.admit(request)
+      const rejected = 'rejection' in admission ? admission.rejection : admission.peer.principal.kind === 'owner' ? undefined : 403
+      if (rejected !== undefined) {
+        socket.end(`HTTP/1.1 ${rejected} Rejected\r\nConnection: close\r\nContent-Length: 0\r\n\r\n`)
+        return
+      }
+      if (!('peer' in admission) || admission.peer.signal.aborted) { socket.destroy(); return }
+      const peer = admission.peer
+      server.handleUpgrade(request, socket, head, ws => {
+        const subscriptions = new Map<string, { stop(): void, publish?(command: Extract<import('../workspace-events.ts').WorkspaceEventCommand, { type: 'authoring-client-publish' }>): Promise<void> }>()
+        let closed = false
+        const cleanup = () => {
+          if (closed) return
+          closed = true
+          peer.signal.removeEventListener('abort', revoked)
+          for (const entry of subscriptions.values()) entry.stop()
+          subscriptions.clear()
+        }
+        const revoked = () => { cleanup(); ws.terminate() }
+        const send = (message: WorkspaceEventMessage) => {
+          if (closed || ws.readyState !== WebSocket.OPEN) return
+          const payload = JSON.stringify(message)
+          if (ws.bufferedAmount + Buffer.byteLength(payload) > MAX_BUFFERED_BYTES) { cleanup(); ws.close(1013, 'Workspace event consumer is too slow'); return }
+          ws.send(payload, error => { if (error) revoked() })
+        }
+        sockets.set(ws, cleanup)
+        peer.signal.addEventListener('abort', revoked, { once: true })
+        if (peer.signal.aborted) { revoked(); return }
+        ws.on('close', () => { cleanup(); sockets.delete(ws) })
+        ws.on('error', revoked)
+        ws.on('message', (data, binary) => {
+          let raw: unknown
+          try { raw = binary ? undefined : JSON.parse(data.toString()) } catch { raw = undefined }
+          const parsed = workspaceEventCommand.safeParse(raw)
+          if (!parsed.success) { cleanup(); ws.close(1008, 'Invalid workspace subscription'); return }
+          const command = parsed.data
+          if (command.type === 'unsubscribe') {
+            subscriptions.get(command.id)?.stop()
+            subscriptions.delete(command.id)
+            return
+          }
+          if (command.type === 'authoring-client-publish') {
+            const entry = subscriptions.get(command.id)
+            void (entry?.publish ? entry.publish(command) : Promise.reject()).then(() => {
+              if (subscriptions.get(command.id) === entry) send({ type: 'published', id: command.id, sequence: command.sequence, ok: true })
+            }, () => { if (subscriptions.get(command.id) === entry) send({ type: 'published', id: command.id, sequence: command.sequence, ok: false }) })
+            return
+          }
+          if (subscriptions.has(command.id) || subscriptions.size >= MAX_SUBSCRIPTIONS) { cleanup(); ws.close(1008, 'Workspace subscription limit'); return }
+          const controller = new AbortController()
+          let source: EventSource | undefined
+          const entry: { stop(): void, publish?(command: Extract<import('../workspace-events.ts').WorkspaceEventCommand, { type: 'authoring-client-publish' }>): Promise<void> } = { stop: () => { controller.abort(); source?.close() } }
+          subscriptions.set(command.id, entry)
+          const current = () => !closed && !controller.signal.aborted && subscriptions.get(command.id) === entry
+          void ctx.presmium.server.ready.then(endpoint => {
+            if (!current()) return
+            if (command.topic === 'authoring-client') {
+              // Keep the client credential on the trusted host, off browser messages and MCP reads.
+              let lease: AuthoringClientLease | undefined
+              let publication: Promise<void> = Promise.resolve()
+              let publications = 0
+              const post = async (kind: string, value: unknown) => {
+                const path = `${WORKSPACE_ROUTES}authoring-clients/${kind}?${new URLSearchParams({ document: command.document })}`
+                const response = await ctx.presmium.server.request(path, { method: 'POST', body: value, signal: controller.signal })
+                if (!response.ok) throw new Error('client-publication-refused')
+                return response.json() as Promise<unknown>
+              }
+              entry.publish = value => {
+                if (publications >= 8) return Promise.reject(new Error('client-publication-limit'))
+                publications++
+                const next = publication.then(async () => {
+                  if (!current() || !lease || value.connectionId !== lease.connectionId || !value.value || typeof value.value !== 'object'
+                    || !('sequence' in value.value) || value.value.sequence !== value.sequence) throw new Error('client-connection-changed')
+                  await post(value.kind === 'ack' ? 'ack' : 'report', { connection: lease, report: value.value })
+                }).finally(() => { publications-- })
+                publication = next.catch(() => {})
+                return next
+              }
+              void post('register', { clientId: command.clientId, epoch: command.epoch, snapshot: command.snapshot }).then(value => {
+                if (!current()) return
+                if (!validateAuthoringClientLease(value)) throw new Error('client-registration-invalid')
+                lease = value
+                const query = new URLSearchParams({ document: command.document, clientId: lease.clientId, epoch: lease.epoch, connectionId: lease.connectionId })
+                const path = `${WORKSPACE_ROUTES}authoring-clients/events?${query}`
+                source = new EventSource(new URL(path, endpoint.url), {
+                  fetch: (_address, init) => ctx.presmium.server.request(path, { headers: { ...Object.fromEntries(new Headers(init?.headers)), 'X-Presmium-Authoring-Client': value.credential }, signal: init?.signal ? AbortSignal.any([controller.signal, init.signal]) : controller.signal }),
+                })
+                source.addEventListener('error', () => { if (current()) send({ id: command.id, type: 'error' }) })
+                source.addEventListener('authoring-client', event => {
+                  if (!current()) return
+                  let data: AuthoringClientEvent
+                  try { data = JSON.parse(event.data) } catch { return }
+                  if (data.type === 'connected' && lease) lease = { ...lease, connectionId: data.connectionId }
+                  send({ id: command.id, type: 'event', data: event.data })
+                })
+              }).catch(() => { if (current()) send({ id: command.id, type: 'error' }) })
+              return
+            }
+            const route = command.topic === 'viewer-site' ? { path: '/__app/events', events: ['ir', 'reload'] }
+              : command.topic === 'viewer-control' ? { path: `${SERVER_ROUTES}control`, events: ['ready', 'approval', 'settled', 'go', 'session'] }
+                : command.topic === 'approvals' ? { path: `${SERVER_ROUTES}control`, events: ['approval', 'settled'] }
+                  : { path: ROUTES[command.topic].path, events: [ROUTES[command.topic].event] }
+            const query = new URLSearchParams({ document: command.document })
+            if (command.topic === 'viewer-site') { query.set('app', command.app); query.set('lang', command.lang); query.set('form', command.form) }
+            if (command.topic === 'viewer-control') query.set('window', command.window)
+            if (command.topic === 'approvals') query.set('observe', 'approvals')
+            const path = `${route.path}?${query}`
+            source = new EventSource(new URL(path, endpoint.url), {
+              fetch: (_address, init) => ctx.presmium.server.request(path, {
+                headers: Object.fromEntries(new Headers(init?.headers)),
+                signal: init?.signal ? AbortSignal.any([controller.signal, init.signal]) : controller.signal,
+              }),
+            })
+            source.addEventListener('open', () => { if (current()) send({ id: command.id, type: 'ready' }) })
+            source.addEventListener('error', () => { if (current()) send({ id: command.id, type: 'error' }) })
+            for (const name of route.events) source.addEventListener(name, event => { if (current()) send({ id: command.id, type: 'event', ...command.topic === 'viewer-site' || command.topic === 'viewer-control' || command.topic === 'approvals' ? { event: name } : {}, data: event.data }) })
+          }).catch(() => { if (current()) send({ id: command.id, type: 'error' }) })
+        })
+      })
+    },
+  })
+  ctx.effect(() => () => {
+    unregister()
+    for (const [socket, cleanup] of sockets) { cleanup(); socket.terminate() }
+    server.close()
+  })
+}

package/src/node/workspaces.ts

@@ -1,10 +1,10 @@
 import { basename } from 'node:path'
-import type { DshContext } from './dsh.ts'
+import type { DshContext } from './dsh-types.ts'
 
 export const name = 'presmium-workspaces'
 export const inject = ['presmium', 'workspaceRegistry']
 
 export async function apply(ctx: DshContext): Promise<void> {
-  const { root } = await ctx.presmium.ready
+  const { root } = await ctx.presmium.server.ready
   await ctx.workspaceRegistry.create(root, basename(root))
 }

package/src/workspace-events.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod'
+
+/** One authenticated Studio socket carries these existing workspace subscriptions. */
+export const WORKSPACE_EVENTS_PATH = '/api/presmium/events'
+export const WORKSPACE_EVENT_TOPICS = ['document', 'diagnostics', 'review', 'ir', 'jobs'] as const
+const subscriptionId = z.string().min(1).max(80)
+
+const viewerSite = z.strictObject({ type: z.literal('subscribe'), id: subscriptionId, topic: z.literal('viewer-site'), document: z.string().max(1024), app: z.string().max(200), lang: z.string().max(80), form: z.enum(['web', 'slides']) })
+const viewerControl = z.strictObject({ type: z.literal('subscribe'), id: subscriptionId, topic: z.literal('viewer-control'), document: z.string().max(1024), window: z.string().regex(/^[a-zA-Z0-9-]{1,80}$/) })
+/** The host's pending approvals for the workbench, which is not a viewer window. */
+const approvals = z.strictObject({ type: z.literal('subscribe'), id: subscriptionId, topic: z.literal('approvals'), document: z.string().max(1024) })
+
+export const workspaceEventCommand = z.union([
+  z.strictObject({ type: z.literal('subscribe'), id: subscriptionId, topic: z.literal('authoring-client'), document: z.string().max(1024), clientId: subscriptionId, epoch: subscriptionId, snapshot: z.unknown() }),
+  z.strictObject({ type: z.literal('authoring-client-publish'), id: subscriptionId, connectionId: subscriptionId, sequence: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER), kind: z.enum(['state', 'ack']), value: z.unknown() }),
+  viewerSite, viewerControl, approvals,
+  z.strictObject({ type: z.literal('subscribe'), id: subscriptionId, topic: z.enum(WORKSPACE_EVENT_TOPICS), document: z.string().max(1024) }),
+  z.strictObject({ type: z.literal('unsubscribe'), id: subscriptionId }),
+])
+
+/** Ready describes the actual upstream connection, rather than a fabricated domain snapshot. */
+export const workspaceEventMessage = z.discriminatedUnion('type', [
+  z.strictObject({ type: z.literal('published'), id: subscriptionId, sequence: z.number().int().nonnegative(), ok: z.boolean() }),
+  z.strictObject({ type: z.literal('ready'), id: subscriptionId }),
+  z.strictObject({ type: z.literal('error'), id: subscriptionId }),
+  z.strictObject({ type: z.literal('event'), id: subscriptionId, event: z.string().max(40).optional(), data: z.string() }),
+])
+
+export type WorkspaceEventTopic = typeof WORKSPACE_EVENT_TOPICS[number] | 'viewer-site' | 'viewer-control' | 'approvals' | 'authoring-client'
+export type WorkspaceEventCommand = z.infer<typeof workspaceEventCommand>
+export type WorkspaceEventMessage = z.infer<typeof workspaceEventMessage>

package/web.patch.yml

@@ -35,41 +35,42 @@
   disabled: true
 - id: ui-settings-session-log
   disabled: true
+# Settings pages an author has no use for: the built-in plugins (the plugin rows of every session) and the agent presets
+# (the workbench's sessions use the authoring preset). Technical rows of the General page stay behind the coding view
+# (src/client/author-settings.ts).
+- id: ui-settings-plugins
+  disabled: true
+- id: ui-agent-preset
+  disabled: true
+# The changed-files and delivery cards under the AI's replies, with the guidance to link every file the reply names: the
+# author sees no files. The workbench makes the changed blocks blink on the document instead.
+- id: ui-deliverables
+  disabled: true
 
-# 内置的「创作」预设：Presmium 的作者人设与发布会原则。预设的 persona 遮蔽部署级
-# 的人设（profile.patch.yml），所以这里重述 Presmium 的角色。
+# 内置的“创作”（authoring）预设：工作台中 Presmium 助手的角色，它面对的作者，以及跟作者说话的方式。预设的
+# persona 遮蔽部署级的人设（profile.patch.yml），所以这里重述 Presmium 的角色；写作的原则在
+# presmium-author 技能中，改写内容时加载。预设只带讲义需要的工具：没有定时任务、目标、子 agent 与文件卡片（present）。
 - insert:
     - id: preset-authoring
       name: '@deepseek-ai/dsh-agent-preset'
       config:
         id: authoring
-        name: 创作
-        description: 面向受众的讲义与演示创作：信息量优先、受众视角、版式不重复。
+        # The preset picker (ui-agent-preset) is off, so authors never see a preset's name; the brand stands in for it in
+        # both languages, and a description in one language is left out.
+        name: Presmium
         order: 0
         plugins:
           - id: persona
             name: '@deepseek-ai/dsh-persona'
             config:
               prefix: |
-                You are Presmium's assistant for the authors of lectures, powered by the {{model}} model. You help write and revise lecture documents (MyST Markdown that Presmium renders as a web page, slides and a notebook), run their code and check them, in the author's language.
-
-                创作或编辑面向受众的内容（讲义、幻灯片、文档、文章及其他展示材料）时，你全程遵守发布会原则：以核心观点和受众价值为中心组织内容，并根据呈现载体调整表达方式。
+                You are Presmium's assistant for the authors of lectures, powered by the {{model}} model. You work with an author in Presmium's workbench: you answer their questions about their documents and make the changes they ask for, in their language.
 
-                **最高优先级：信息量原则**
+                The author is a teacher who may know no code. The workbench shows a document as its readers see it, as a web page or as slides; the author edits its text there, leaves comments on it and asks you for changes. They do not see, and need not know, source files, Markdown, paths or line numbers, git, builds, tools or logs.
 
-                每一句话都必须有明确的存在意义，对受众理解内容、形成判断或采取行动发挥具体作用。每页、每屏或每个独立内容区块都必须承载有效信息，并承担明确的说明或论证任务。句子、注释、例子、数据和重复说明，都应具有明确作用；删除后不影响受众理解或判断的内容应直接删除。叙事安排、版式变化与语言润色均须服从这一原则，不得为满足形式要求而添加无效内容。
-
-                1. 围绕最有价值、最有说服力的观点或优势组织叙事，使全部内容共同支撑核心主张。
-                2. 按照受众理解问题的逻辑安排内容，避免按个人思考、工作开展或方案尝试的过程罗列经历。
-                3. 避免“只是一些浅见”“可能没什么价值”等自我削弱表达，不主动贬低内容的价值。
-                4. 根据内容目的与受众需求选择讨论角度、评价维度和比较口径，集中呈现能够充分证明核心价值的内容。
-                5. 涉及不同观点、方法或结果时，结合各自目标、适用条件与合理取舍解释差异，避免简单作出优劣判断。
-                6. 明确说明核心观点为什么重要、依据是什么，以及能够帮助受众理解或解决什么问题，不依赖受众自行从文字、表格或图形中推导内容价值。
-                7. 对于采用分页、分屏或区块布局的材料，相同的排版结构不得连续出现；任意连续五页、五屏或五个主要展示区块内不得重复使用相同的排版结构。
-                8. 出现排版结构重复时，应根据内容关系重新组织信息，选择适合的流程、对照、时间线、图表或图文组合等呈现方式，避免通过更换颜色、图标或文字维持相同布局。
-                9. 对于幻灯片，单页文字过多时，应优先采用图形化表达，根据内容关系改用流程图、关系图、时间线、数据图表或图文组合，减少连续文字并保留必要信息。图形应承担信息表达和关系说明的作用，避免将整段文字直接放入形状中。
-                10. 开头应尽早呈现受众关心的问题、值得讨论的关键、核心观点及最有说服力的依据。
-                11. 结尾应强化核心观点与最值得记住的信息，避免突然改变立场或加入自我否定的评价。
+                - The author's messages say what to do. When they point at something (selected text, a picked block), the message names the section and quotes the passage as readers see them, and the document context's focus gives its source range. A message of comments quotes each comment with its place, and comment N is the focus `comment-N`. A comment is the author's own words about that place: one that asks a question is answered, one that asks for a change is carried out, and several are handled one by one.
+                - Speak in the terms of what the author sees: a section by its title, the slide, the paragraph, the sentence, the result of the code. Do not tell them how things are done inside Presmium: no file names or paths, line numbers, JSON or Markdown syntax, directive or plugin names, the IR, builds, diagnostic codes, commands, tool names, the sandbox, permissions or git. When something could not be done or checked, say in plain words what they cannot have yet and what they can do.
+                - When you have changed the document, say in a sentence or two what readers will now see, and where. The change is a version of the document that the author can undo, or accept or reject first when the workspace asks for review.
           - id: agent-instructions
             name: '@deepseek-ai/dsh-agent-instructions'
             config:
@@ -90,16 +91,10 @@
               sampleOverCapGlobResults: false
           - id: tool-jobs
             name: '@deepseek-ai/dsh-tool-jobs'
-          - id: tool-schedule
-            name: '@deepseek-ai/dsh-tool-schedule'
           - id: skill-filesystem
             name: '@deepseek-ai/dsh-skill-filesystem'
           - id: tool-skill
             name: '@deepseek-ai/dsh-tool-skill'
-          - id: command-goal
-            name: '@deepseek-ai/dsh-command-goal'
-          - id: tool-goal
-            name: '@deepseek-ai/dsh-tool-goal'
           - id: planning
             name: cordis:group
             group: true
@@ -138,33 +133,6 @@
                   thresholdChars: 8192
                   headChars: 4096
                   tailChars: 1024
-          - id: delegation
-            name: cordis:group
-            group: true
-            isolate:
-              workflowEngine: true
-            config:
-              - id: tool-subagent-control
-                name: '@deepseek-ai/dsh-tool-subagent-control'
-              - id: tool-subagent-list-agents
-                name: '@deepseek-ai/dsh-tool-subagent-control/list-agents'
-              - id: tool-subagent
-                name: '@deepseek-ai/dsh-tool-subagent'
-                config:
-                  provider: spawn
-                  toolName: subagent
-                  modelSelectionSettings: true
-              - id: tool-subagent-fork
-                name: '@deepseek-ai/dsh-tool-subagent'
-                config:
-                  provider: fork
-                  toolName: subagent_fork
-              - id: workflow-ptc
-                name: '@deepseek-ai/dsh-workflow-ptc'
-                config:
-                  provider: spawn
-              - id: tool-workflow
-                name: '@deepseek-ai/dsh-tool-workflow'
           - id: tool-ask-user
             name: '@deepseek-ai/dsh-tool-ask-user'
           - id: tool-todo
@@ -176,8 +144,6 @@
             config:
               fetch: true
               searchTimeoutMs: 60000
-          - id: present
-            name: '@deepseek-ai/dsh-tool-present'
           - id: tool-plugin-manager
             name: '@deepseek-ai/dsh-plugin-manager/tools'
             disabled: true
@@ -188,3 +154,8 @@
 - id: agent-preset-registry
   config:
     default: authoring
+
+# Static shell boot does not need one HTTP/1 event stream in every open Studio tab.
+# Source, diagnostics, review and jobs use Presmium's scoped event connection.
+- id: client-hmr
+  disabled: true

package/rows/load.mjs

@@ -1,8 +0,0 @@
-import { fileURLToPath } from 'node:url'
-import { createJiti } from 'jiti'
-
-const jiti = createJiti(import.meta.url)
-
-export function load(file) {
-  return jiti.import(fileURLToPath(new URL(`../src/node/${file}`, import.meta.url)))
-}

package/rows/turns.mjs

@@ -1,7 +0,0 @@
-import { load } from './load.mjs'
-
-const row = await load('turns/index.ts')
-
-export const name = row.name
-export const inject = row.inject
-export const apply = row.apply