@lincyaw/dsh 0.0.0-stage → 0.2.0-rc.0

package/src/node/routes.ts

@@ -0,0 +1,56 @@
+import type { DshContext } from './dsh-types.ts'
+import { SERVER_ROUTES, WORKSPACE_ROUTES } from './server-routes.ts'
+
+export const name = 'presmium-routes'
+export const inject = ['presmium', 'connection']
+
+export const ROUTES: Record<string, string> = Object.fromEntries([
+  ['speech-settings', `${WORKSPACE_ROUTES}speech-settings`],
+  ...['project/capabilities', 'project/plan', 'project/apply', 'documents', 'document', 'document/capabilities', 'document/outline', 'document/part', 'document/page/plan', 'document/page/apply', 'document/action/plan', 'document/action/impact', 'document/action/apply', 'document/asset', 'document/events', 'document/change', 'document/image', 'document/audio', 'document/recording/adopt', 'document/media-clip', 'files', 'source', 'source/create', 'source/transaction', 'changes', 'changes/commit', 'changes/discard', 'revisions', 'revisions/revert', 'history/list', 'history/file', 'history/undo', 'history/redo',
+    'document/media-clip/validate', 'document/transcription/capabilities', 'document/transcription', 'document/transcription/result', 'document/transcription/cancel',
+    'document/transcription/adoption/plan', 'document/transcription/adoption/apply',
+    'ir', 'ir/events', 'preview', 'build', 'check', 'jobs', 'jobs/cancel', 'jobs/events', 'voice-catalog', 'voice-capabilities',
+    'review', 'review/open', 'review/step', 'review/accept', 'review/reject', 'review/restore'].map(path => [path, `${WORKSPACE_ROUTES}${path}`]),
+  ['focus', `${SERVER_ROUTES}focus`],
+  ['control', `${SERVER_ROUTES}control`],
+  ['diagnostics', `${SERVER_ROUTES}diagnostics`],
+  ['diagnostics/events', `${SERVER_ROUTES}diagnostics/events`],
+  ['diagnostics/authoring', `${SERVER_ROUTES}diagnostics/authoring`],
+  ...['voiceover', 'voiceover/jobs', 'voiceover/job', 'voiceover/cancel', 'voice-preview', 'voice-preview/media', 'production-plan', 'production-media', 'production-asset'].map(path => [path, `/__presmium/presmium.lecture/${path}`]),
+  // Training a cloned voice and its status: the speech plugin's owner routes.
+  ['voice-clone', '/__presmium/presmium.speech/clone'],
+  ['voice-clone/status', '/__presmium/presmium.speech/clone/status'],
+])
+
+const PASSED = ['accept', 'content-type', 'presmium-document', 'last-event-id', 'if-none-match']
+const RETURNED = ['content-type', 'cache-control', 'content-disposition', 'content-security-policy', 'x-content-type-options', 'cross-origin-resource-policy', 'x-accel-buffering', 'etag', 'retry-after']
+
+export function apply(ctx: DshContext): void {
+  for (const [path, target] of Object.entries(ROUTES)) {
+    ctx.connection.fetch.register({
+      path: `/api/presmium/${path}`,
+      methods: ['GET', 'POST'],
+      requestBody: 'buffered',
+      async fetch(request) {
+        const headers: Record<string, string> = {}
+        for (const name of PASSED) {
+          const value = request.headers.get(name)
+          if (value !== null) headers[name] = value
+        }
+        const upstream = await ctx.presmium.server.request(`${target}${new URL(request.url).search}`, {
+          method: request.method,
+          headers,
+          ...request.method === 'POST' ? { raw: await request.arrayBuffer() } : {},
+          signal: request.signal,
+        })
+        if ((path === 'documents' || path === 'project/apply') && request.method === 'POST' && upstream.ok) ctx.presmium.server.invalidateDocuments()
+        const answered = new Headers()
+        for (const name of RETURNED) {
+          const value = upstream.headers.get(name)
+          if (value !== null) answered.set(name, value)
+        }
+        return new Response(upstream.body, { status: upstream.status, headers: answered })
+      },
+    })
+  }
+}

package/src/node/server-routes.ts

@@ -0,0 +1,3 @@
+/** Where the workspace server mounts the routes of its workspace plugin and its own routes. */
+export const WORKSPACE_ROUTES = '/__presmium/presmium.workspace/'
+export const SERVER_ROUTES = '/__presmium/presmium.server/'

package/src/node/service.ts

@@ -0,0 +1,131 @@
+import { randomBytes } from 'node:crypto'
+import { createRequire } from 'node:module'
+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'
+
+export interface Config {
+  url?: string
+  token?: string
+  root?: string
+}
+
+export interface Endpoint {
+  url: string
+  serviceToken: string
+  root: string
+}
+
+/** What the row provides to the other rows as `ctx.presmium`. */
+export interface Presmium {
+  server: WorkspaceServerClient
+  bindings: DocumentBindings
+}
+
+const DOCUMENTS_MS = 2000
+
+/** 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')
+}
+
+/** 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 #launched: LaunchedProcess | undefined
+  #documents: { at: number, list: Promise<DocumentSummary[]> } | undefined
+  #closed = false
+
+  constructor(config: Config, log: DshLogger) {
+    const root = resolve(config.root || process.cwd())
+    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}`)
+        },
+      })
+      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, 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, ...serviceToken ? { Authorization: `Bearer ${serviceToken}` } : {} },
+      ...json ? { body: JSON.stringify(init.body) } : init.raw ? { body: init.raw } : {},
+      ...init.signal ? { signal: init.signal } : {},
+    })
+  }
+
+  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
+  }
+
+  /** 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.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
+  }
+
+  /** 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
+    if (this.#launched) {
+      this.#launched.child.kill('SIGTERM')
+      return
+    }
+    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.#launched?.child.exitCode === null) this.#launched.child.kill('SIGTERM')
+  }
+}
+
+export function apply(ctx: DshContext, config: Config = {}): void {
+  const log = ctx.logger?.('presmium') ?? console
+  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 bindings.close().then(() => server.close())
+  })
+}

package/src/node/skills.ts

@@ -0,0 +1,24 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { listBundledSkills, skillDirectory } from '@lincyaw/skills'
+import type { DshContext } from './dsh-types.ts'
+
+export const name = 'presmium-skills'
+export const inject = ['skills']
+
+export function bundledSkills(): string[] {
+  return listBundledSkills().map(skill => skill.name)
+}
+
+export function skillDir(skill: string): string | undefined {
+  try { return skillDirectory(skill) } catch { return undefined }
+}
+
+export function apply(ctx: DshContext): void {
+  for (const skill of listBundledSkills()) {
+    const dir = skillDirectory(skill.name)
+    const path = join(dir, 'SKILL.md')
+    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

@@ -0,0 +1,66 @@
+import type { ListedTool } from '@lincyaw/mcp/client'
+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(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 binding.client.call(tool.name, (args ?? {}) as Record<string, unknown>, exec.signal)
+      if (result.isError) throw new Error(result.text)
+      return result.text
+    },
+  }
+}
+
+export function apply(ctx: DshContext): void {
+  const live = new WeakSet<DshAgent>()
+  const selections = new WeakMap<DshAgent, () => void>()
+  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.binding === binding && previous.tools === binding?.tools) return
+    previous?.stop?.()
+    for (const dispose of previous?.dispose ?? []) dispose()
+    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)
+    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/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))
+  })
+}

package/src/node/turns.ts

@@ -0,0 +1,176 @@
+import { randomUUID } from 'node:crypto'
+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 WRITING_TOOLS = new Set(['write', 'edit', 'str_replace_editor', 'bash', 'pwsh', 'terminal_send'])
+
+const REVIEW = `${WORKSPACE_ROUTES}review`
+const RETRY_MS = 2000
+
+interface LiveAgent extends DshAgent {
+  inject(message: unknown): void
+}
+
+interface SessionEvent {
+  type: string
+  data?: { turn?: number }
+}
+
+interface Reverted {
+  type: 'reverted'
+  session: string
+  turns?: string
+  revision: string
+  subject: string
+  revertedBy: string
+  files: string[]
+}
+
+/** The turn an agent session is in, and whether a tool wrote in it (to which document's review). */
+interface TurnState {
+  turn?: number
+  document?: string
+  wrote: boolean
+}
+
+function labelOf(exec: Readonly<DshToolExecution>): string {
+  const args = (exec.arguments ?? {}) as { file_path?: unknown, path?: unknown, command?: unknown, input?: unknown }
+  const what = [args.file_path, args.path, args.command, args.input].find(value => typeof value === 'string' && value.trim())
+  return what ? `${exec.name} ${String(what).replace(/\s+/g, ' ').trim().slice(0, 160)}` : exec.name
+}
+
+export function revertNotice(event: Reverted): unknown {
+  const short = (id: string) => id.slice(0, 10)
+  const files = event.files.length ? event.files.join(', ') : 'its files'
+  const turns = event.turns ? ` (turns ${event.turns})` : ''
+  const text = `[Presmium] The author undid the change this session made${turns}: commit ${short(event.revision)} "${event.subject}", undone by commit ${short(event.revertedBy)}. ${files} ${event.files.length === 1 ? 'is' : 'are'} back as before that change. Read a file again before you edit it, and do not make that change again unless the author asks.`
+  const summary = `Presmium: the author undid commit ${short(event.revision)}${turns}`
+  return Object.freeze({ id: randomUUID(), role: 'user', content: Object.freeze([Object.freeze({ type: 'text', text })]), source: Object.freeze({ kind: 'presmium', form: 'notice', summary: summary.slice(0, 120) }) })
+}
+
+export function apply(ctx: DshContext): void {
+  const log = ctx.logger?.('presmium') ?? console
+  const turnStates = new Map<string, TurnState>()
+  const agents = new Map<string, LiveAgent>()
+  const pending = new Map<string, unknown[]>()
+  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>()
+  /** 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 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(NOT_RECORDED)
+    let reason = text
+    try {
+      reason = (JSON.parse(text) as { error?: string, detail?: string }).error ?? reason
+    } catch {
+    }
+    throw new Error(reason || `the review answered ${response.status}`)
+  }
+
+  ctx.on('session/event', (session: { id: string }, event: SessionEvent) => {
+    if (event.type === 'turn/start' && typeof event.data?.turn === 'number') turnStateOf(session.id).turn = event.data.turn
+    if (event.type !== 'turn/end') return
+    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>) => {
+    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 postReview(document, agentSessionId, 'open', state.turn !== undefined ? { turn: state.turn } : {})
+    } catch (error) {
+      throw new Error(`${errorMessage(error)} ${NOTHING_CHANGED}`)
+    }
+    state.document = document
+    state.wrote = true
+    try {
+      return await next()
+    } finally {
+      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)}`))
+    }
+  })
+
+  ctx.on('agent/created', ({ agent }: { agent: LiveAgent }) => {
+    const header = agent.session.header as { origin?: string, parentSession?: string } | undefined
+    if (header?.origin === 'subagent' && header.parentSession) parents.set(agent.session.id, header.parentSession)
+    agents.set(agent.session.id, agent)
+    for (const notice of pending.get(agent.session.id) ?? []) agent.inject(notice)
+    pending.delete(agent.session.id)
+  })
+  ctx.on('agent/disposed', ({ agent }: { agent: LiveAgent }) => {
+    if (agents.get(agent.session.id) === agent) agents.delete(agent.session.id)
+  })
+  ctx.on('session/disposed', (session: { id: string }) => {
+    turnStates.delete(session.id)
+    parents.delete(session.id)
+  })
+
+  const injectRevertNotice = (event: Reverted) => {
+    const notice = revertNotice(event)
+    const agent = agents.get(event.session)
+    if (agent) agent.inject(notice)
+    else pending.set(event.session, [...pending.get(event.session) ?? [], notice])
+    log.info(`presmium-turns: told session ${event.session} that commit ${event.revision} was undone`)
+  }
+
+  const stop = new AbortController()
+  const subscribeReviewEvents = async () => {
+    while (!stop.signal.aborted) {
+      try {
+        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 = ''
+        for await (const chunk of response.body) {
+          buffer += decoder.decode(chunk as Uint8Array, { stream: true })
+          let end: number
+          while ((end = buffer.indexOf('\n\n')) >= 0) {
+            const block = buffer.slice(0, end)
+            buffer = buffer.slice(end + 2)
+            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') injectRevertNotice(event as Reverted)
+          }
+        }
+      } catch (error) {
+        if (stop.signal.aborted) return
+        log.debug(`presmium-turns: the review events: ${errorMessage(error)}`)
+      }
+      await new Promise(done => setTimeout(done, RETRY_MS).unref())
+    }
+  }
+  void subscribeReviewEvents()
+  ctx.effect(() => () => stop.abort())
+}

package/src/node/watchdog.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+
+const GRACE_MS = 5000
+
+const [command, ...args] = process.argv.slice(2)
+if (!command) {
+  process.stderr.write('usage: watchdog.mjs <command> [args...]\n')
+  process.exit(2)
+}
+
+const group = (signal) => {
+  try {
+    process.kill(-process.pid, signal)
+  } catch {
+  }
+}
+
+const child = spawn(command, args, { stdio: ['ignore', 'inherit', 'inherit'] })
+let ending = false
+const end = () => {
+  if (ending) return
+  ending = true
+  group('SIGTERM')
+  setTimeout(() => group('SIGKILL'), GRACE_MS).unref()
+}
+
+process.on('SIGTERM', end)
+process.on('SIGINT', end)
+process.stdin.on('end', end).on('close', end).on('error', end)
+process.stdin.resume()
+child.on('error', (error) => {
+  process.stderr.write(`watchdog: ${error.message}\n`)
+  process.exit(1)
+})
+child.on('exit', () => group('SIGKILL'))