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

package/src/node/workbench.ts

@@ -0,0 +1,88 @@
+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', '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>')}`
+
+export function brandIndex(html: string): string {
+  return html
+    .replace(/<title>[^<]*<\/title>/, '<title>Presmium</title>')
+    .replace(/<link rel="(?:icon|manifest)"[^>]*>\s*/g, '')
+    .replace('</head>', `<link rel="icon" type="image/svg+xml" href="${ICON}" />\n</head>`)
+}
+
+interface WebServer {
+  tapIndex(transform: (html: string) => string): () => 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',
+    async fetch(request) {
+      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.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.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

@@ -0,0 +1,10 @@
+import { basename } from 'node:path'
+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.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

@@ -0,0 +1,161 @@
+- insert:
+    - id: presmium-workspaces
+      name: '@lincyaw/dsh/workspaces'
+    - id: presmium-routes
+      name: '@lincyaw/dsh/routes'
+
+- id: workspace-controller
+  config:
+    documentsDirectory: !!js (process.env.DSH_HOME || `${process.env.XDG_STATE_HOME || `${process.env.HOME}/.local/state`}/presmium/studio`) + '/documents'
+
+- id: harness-dev-context
+  disabled: true
+
+- insert:
+    - id: presmium-workbench
+      name: '@lincyaw/dsh'
+
+- id: ui-layout
+  disabled: true
+- id: ui-sidebar
+  disabled: true
+- id: ui-brand-official
+  disabled: true
+- id: ui-settings-account
+  disabled: true
+- id: account-controller
+  disabled: true
+- id: deepseek-account
+  disabled: true
+- id: llm-deepseek-account
+  disabled: true
+- id: web-search-deepseek
+  disabled: true
+- id: ui-settings-web-search
+  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
+
+# 内置的“创作”（authoring）预设：工作台中 Presmium 助手的角色，它面对的作者，以及跟作者说话的方式。预设的
+# persona 遮蔽部署级的人设（profile.patch.yml），所以这里重述 Presmium 的角色；写作的原则在
+# presmium-author 技能中，改写内容时加载。预设只带讲义需要的工具：没有定时任务、目标、子 agent 与文件卡片（present）。
+- insert:
+    - id: preset-authoring
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: authoring
+        # 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 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.
+
+                - 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:
+              maxBytes: 65536
+          - id: time-context
+            name: '@deepseek-ai/dsh-time-context'
+          - id: tool-bash
+            name: '@deepseek-ai/dsh-tool-bash'
+            disabled: !!js process.platform === 'win32'
+          - id: tool-pwsh
+            name: '@deepseek-ai/dsh-tool-pwsh'
+            disabled: !!js process.platform !== 'win32'
+          - id: tool-fs
+            name: '@deepseek-ai/dsh-tool-fs'
+          - id: tool-fs-search
+            name: '@deepseek-ai/dsh-tool-fs-search'
+            config:
+              sampleOverCapGlobResults: false
+          - id: tool-jobs
+            name: '@deepseek-ai/dsh-tool-jobs'
+          - id: skill-filesystem
+            name: '@deepseek-ai/dsh-skill-filesystem'
+          - id: tool-skill
+            name: '@deepseek-ai/dsh-tool-skill'
+          - id: planning
+            name: cordis:group
+            group: true
+            isolate:
+              planMode: true
+            config:
+              - id: plan-mode
+                name: '@deepseek-ai/dsh-plan-mode'
+                config:
+                  section: |
+                    You are in plan mode. Stay in plan mode until the user approves your plan through exit_plan_mode or switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
+
+                    Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
+
+                    The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
+
+                    Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
+
+                    Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
+
+                    When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
+          - id: compaction
+            name: cordis:group
+            group: true
+            isolate:
+              compaction: true
+              toolResultPruner: true
+            config:
+              - id: compaction-basic
+                name: '@deepseek-ai/dsh-compaction-basic'
+              - id: command-compact
+                name: '@deepseek-ai/dsh-command-compact'
+              - id: tool-result-pruner
+                name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
+                config:
+                  thresholdChars: 8192
+                  headChars: 4096
+                  tailChars: 1024
+          - id: tool-ask-user
+            name: '@deepseek-ai/dsh-tool-ask-user'
+          - id: tool-todo
+            name: '@deepseek-ai/dsh-tool-todo'
+            config:
+              allowParallelInProgress: true
+          - id: tool-web
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              fetch: true
+              searchTimeoutMs: 60000
+          - id: tool-plugin-manager
+            name: '@deepseek-ai/dsh-plugin-manager/tools'
+            disabled: true
+          - id: tool-plugin-market
+            name: '@deepseek-ai/dsh-plugin-market/tools'
+            disabled: true
+
+- 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