@lincyaw/dsh 0.1.0 → 0.2.0-rc.0

package/src/client/RootLayout.tsx

@@ -0,0 +1,332 @@
+import { Group, Panel, Separator, usePanelRef } from 'react-resizable-panels'
+import { DocumentView, HomePanel, PmDialog, PmIcon, PmMenu, SHORTCUTS, useWorkbenchState, WorkbenchApprovals, WorkbenchProvider } from '@lincyaw/workbench'
+import type { Workbench } from '@lincyaw/workbench'
+import { useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react'
+import type { ReactNode, RefObject } from 'react'
+import { Logo } from './brand.tsx'
+import { mainViewAgentSession } from './document-context.ts'
+import { clamp, CONVERSATION_MAX, CONVERSATION_MIN, NARROW, RIGHTBAR_MAX_RATIO, RIGHTBAR_MIN, rightbarRoom, SIDE_COLLAPSE, SIDE_MAX, SIDE_MIN } from './layout.ts'
+import type { LayoutActions, LayoutState, NarrowPane } from './layout.ts'
+import { useClientMessages } from './messages.ts'
+import { isSamePath } from './paths.ts'
+import { RuntimeDiagnosticsNotice, WorkbenchRuntimeBoundary } from './runtime-diagnostics.tsx'
+
+interface RootSlotProps {
+  useStore: DshSelectorHook<LayoutState>
+  useSessions: DshSelectorHook<{ byId: Record<string, { id: string, title?: string, cwd?: string, retainedBy: { mainView?: number } }> }>
+  usePanelInfo: DshSelectorHook<LayoutState['panelInfo']>
+  actions: LayoutActions
+  renderSlot(name: string, props?: Record<string, unknown>, options?: Record<string, unknown>): ReactNode
+}
+
+export interface RootLayoutOptions {
+  workbench: Workbench
+  openSettings(): void
+  /** Opens a DeepSeek Harness workspace in the main view, keeping the current layout. */
+  openDshWorkspace(id: string): Promise<void>
+  dshWorkspaces: DshObservable<{ items: readonly { workspaceId: string, path: string }[] }>
+  globalPanels: DshObservable<readonly DshSlotEntry[]>
+}
+
+type Geometry = ReturnType<typeof solveGeometry>
+type Box = { left: number, top: number, width: number, height: number }
+
+/** The component of the `root` slot: the root layout with the workbench of `options`. */
+export function rootLayoutFor(options: RootLayoutOptions) {
+  return function PresmiumRootLayout(props: RootSlotProps) {
+    return (
+      <WorkbenchProvider workbench={options.workbench}>
+        <WorkbenchRuntimeBoundary workbench={options.workbench}><RootLayout {...props} {...options} /></WorkbenchRuntimeBoundary>
+      </WorkbenchProvider>
+    )
+  }
+}
+
+/** The columns' widths for the viewport: 0 for a column that is not shown. */
+function solveGeometry(info: LayoutState['layoutInfo']) {
+  const viewport = info.viewportWidth
+  const narrow = viewport < NARROW
+  const collapsed = viewport < SIDE_COLLAPSE
+  const side = narrow ? 0 : (collapsed ? info.isSideExpanded : info.isSideOpen) ? info.sideWidth : 0
+  const conversation = narrow || !info.isConversationOpen ? 0 : collapsed ? Math.min(info.conversationWidth, Math.max(300, Math.round(viewport * 0.4))) : info.conversationWidth
+  const room = rightbarRoom(viewport, side, conversation, 3)
+  const besideChat = room >= RIGHTBAR_MIN ? room : rightbarRoom(viewport, 0, conversation, 2)
+  const available = besideChat >= RIGHTBAR_MIN || info.isRightbarOpen ? besideChat : rightbarRoom(viewport, 0, 0, 2)
+  const preference = info.rightbarWidth ?? Math.round(viewport * 0.3)
+  const rightbar = narrow || available < RIGHTBAR_MIN ? 0 : Math.min(available, clamp(preference, RIGHTBAR_MIN, viewport * RIGHTBAR_MAX_RATIO))
+  return { viewport, narrow, collapsed, side, conversation, rightbar, track: info.hasRightbarTrack ? rightbar : 0 }
+}
+
+/** Reports the frame's width to the layout store, at most once a frame. */
+function useViewportWidth(frame: RefObject<HTMLDivElement>, actions: LayoutActions): void {
+  useLayoutEffect(() => {
+    const element = frame.current!
+    let raf: number | undefined
+    const measure = () => {
+      const width = element.getBoundingClientRect().width
+      if (width > 0) actions.setViewportWidth(width)
+    }
+    measure()
+    const observer = new ResizeObserver(() => {
+      raf ??= requestAnimationFrame(() => {
+        raf = undefined
+        measure()
+      })
+    })
+    observer.observe(element)
+    return () => {
+      observer.disconnect()
+      if (raf !== undefined) cancelAnimationFrame(raf)
+    }
+  }, [actions])
+}
+
+/** The rightbar track's box in the frame: the overlay that draws the rightbar follows the resized track. */
+function useRightbarBox(frame: RefObject<HTMLDivElement>, track: RefObject<HTMLDivElement>, dependencies: unknown[]): Box | undefined {
+  const [box, setBox] = useState<Box>()
+  useLayoutEffect(() => {
+    const element = track.current
+    if (!element) { setBox(undefined); return }
+    const measure = () => {
+      const rect = element.getBoundingClientRect()
+      const origin = frame.current!.getBoundingClientRect()
+      setBox(before => before?.left === rect.left - origin.left && before.top === rect.top - origin.top && before.width === rect.width && before.height === rect.height ? before : { left: rect.left - origin.left, top: rect.top - origin.top, width: rect.width, height: rect.height })
+    }
+    measure()
+    const observer = new ResizeObserver(measure)
+    observer.observe(element)
+    observer.observe(frame.current!)
+    return () => observer.disconnect()
+  }, dependencies)
+  return box
+}
+
+/** Opens the workspace root's DeepSeek Harness workspace once at startup, unless the main view's session is already in it. */
+function useOpenStartupWorkspace(workbench: Workbench, dshWorkspaces: RootLayoutOptions['dshWorkspaces'], openDshWorkspace: RootLayoutOptions['openDshWorkspace'], session: { id: string, cwd?: string } | undefined): void {
+  const workspaces = useSyncExternalStore(dshWorkspaces.subscribe, dshWorkspaces.getSnapshot).items
+  const [root, setRoot] = useState<string>()
+  const workspaceId = root ? workspaces.find(workspace => isSamePath(workspace.path, root))?.workspaceId : undefined
+  const opened = useRef(false)
+  useEffect(() => {
+    let active = true
+    void workbench.client.readWorkbenchInfo().then(answer => { if (active) setRoot(answer.root) }).catch(() => {})
+    return () => { active = false }
+  }, [workbench])
+  useEffect(() => {
+    if (!root || opened.current) return
+    if (session?.cwd && isSamePath(session.cwd, root)) {
+      opened.current = true
+      return
+    }
+    if (!workspaceId) return
+    opened.current = true
+    void openDshWorkspace(workspaceId).catch(() => { opened.current = false })
+  }, [root, workspaceId, openDshWorkspace, session?.id, session?.cwd])
+}
+
+/** The page's title: the main view's session, else the open document. */
+function useDocumentTitle(sessionTitle: string | undefined, documentTitle: string | undefined): void {
+  useEffect(() => {
+    const title = sessionTitle ?? documentTitle
+    document.title = title ? `${title} — Presmium` : 'Presmium'
+  }, [sessionTitle, documentTitle])
+}
+
+function RootLayout({ useStore, useSessions, usePanelInfo, actions, renderSlot, workbench, openSettings, openDshWorkspace, dshWorkspaces, globalPanels }: RootSlotProps & RootLayoutOptions) {
+  const info = useStore(state => state.layoutInfo)
+  const activePanel = usePanelInfo(panel => panel.activePanelId)
+  const t = useClientMessages(workbench)
+  const document_ = useWorkbenchState(state => state.document)
+  const retainedDocument = useRef(false)
+  if (document_ !== undefined) retainedDocument.current = true
+  const documentTitle = useWorkbenchState(state => state.documents?.documents.find(doc => doc.dir === state.document)?.title)
+  const session = useSessions(state => mainViewAgentSession(state.byId))
+  const frame = useRef<HTMLDivElement>(null)
+  const rightbarTrack = useRef<HTMLDivElement>(null)
+  const [helpOpen, setHelpOpen] = useState(false)
+  const geometry = solveGeometry(info)
+  const { narrow, collapsed } = geometry
+  const conversationPanel = usePanelRef()
+  const sidePanelRef = usePanelRef()
+  useEffect(() => {
+    if (narrow || info.isConversationOpen) conversationPanel.current?.expand()
+    else conversationPanel.current?.collapse()
+  }, [narrow, info.isConversationOpen, conversationPanel])
+  const sideShown = !narrow && (collapsed ? info.isSideExpanded : info.isSideOpen)
+  useLayoutEffect(() => {
+    if (sideShown || (narrow && info.narrowPane === 'sessions')) sidePanelRef.current?.expand()
+    else sidePanelRef.current?.collapse()
+  }, [sideShown, narrow, info.narrowPane, sidePanelRef])
+
+  const rightbarBox = useRightbarBox(frame, rightbarTrack, [info.isRightbarOpen, info.hasRightbarTrack, info.isRightbarFullscreen, info.isConversationOpen, sideShown, narrow])
+  useViewportWidth(frame, actions)
+
+  const opened = useRef({ document: document_, narrow })
+  useEffect(() => {
+    // Entering the single-pane layout keeps the document the author was viewing on desktop.
+    // Once narrow, explicit navigation to history, chat or the document list remains the user's choice.
+    const documentChanged = document_ !== opened.current.document
+    const enteredNarrow = narrow && !opened.current.narrow
+    if (document_ !== undefined && narrow && (documentChanged || enteredNarrow)) actions.showNarrowPane('preview')
+    if (document_ === undefined && narrow && info.narrowPane === 'preview') actions.showNarrowPane('documents')
+    opened.current = { document: document_, narrow }
+  }, [document_, narrow, actions, info.narrowPane])
+
+  useOpenStartupWorkspace(workbench, dshWorkspaces, openDshWorkspace, session)
+  useDocumentTitle(session?.title, documentTitle)
+
+  const sidebar = useMemo(() => renderSlot('sidebar', { collapsed: false, width: narrow ? geometry.viewport : Math.max(geometry.side, 264) }), [renderSlot, narrow, geometry.viewport, geometry.side])
+  const conversation = useMemo(() => renderSlot('main', {}, { entryKey: 'conversation' }), [renderSlot])
+  const overlays = useMemo(() => renderSlot('shell.overlay', {}), [renderSlot])
+  const bottom = useMemo(() => renderSlot('shell.bottom', {}), [renderSlot])
+  const panel = activePanel !== null ? renderSlot('main', {}, { entryKey: activePanel }) : null
+  const rightbar = renderSlot('rightbar', { width: rightbarBox?.width ?? geometry.rightbar, viewportWidth: geometry.viewport, canShow: geometry.rightbar > 0 })
+
+  const pane: NarrowPane = narrow ? info.narrowPane : 'documents'
+  const documentShown = panel === null && document_ !== undefined && (!narrow || pane === 'preview')
+  const centre = <>
+    {panel !== null && <div className="pmw-frame__panel" data-pmw-slot={`main:${activePanel}`}>{panel}</div>}
+    {retainedDocument.current && <div className="pmw-frame__document" hidden={!documentShown}>
+      <DocumentView active={documentShown} framed />
+    </div>}
+    {panel === null && (document_ === undefined || (narrow && pane === 'documents')) && <HomePanel />}
+  </>
+
+  return (
+    <div
+      ref={frame}
+      className="pmw-frame pm-ui"
+      data-narrow={narrow || undefined}
+      data-collapsed={collapsed || undefined}
+      data-pane={narrow ? pane : undefined}
+      data-rightbar-fullscreen={info.isRightbarFullscreen || undefined}
+    >
+      <a className="pmw-frame__skip" href="#pmw-centre">{t.skip}</a>
+      <AppBar workbench={workbench} info={info} actions={actions} activePanel={activePanel} globalPanels={globalPanels} pane={pane} narrow={narrow} openSettings={openSettings} openHelp={() => setHelpOpen(true)} />
+
+      <RuntimeDiagnosticsNotice workbench={workbench} />
+      <Group className="pmw-frame__panels" disabled={narrow} onLayoutChanged={(layout, meta) => {
+        if (!meta.isUserInteraction) return
+        const width = info.viewportWidth
+        if (layout.sessions !== undefined) actions.setSideWidth(layout.sessions * width / 100)
+        if (layout.sessions === 0 && sideShown) actions.toggleSidebar()
+        if (layout.conversation !== undefined) {
+          actions.setConversationOpen(layout.conversation > 0)
+          if (layout.conversation > 0) actions.setConversationWidth(layout.conversation * width / 100)
+        }
+        if (layout.rightbar !== undefined) actions.setRightbarWidth(layout.rightbar * width / 100)
+      }}>
+        {/* Collapsed, not hidden, on a wide screen: a hidden panel's box sits at the page's corner, and react-resizable-panels takes the gap from it to the centre (the activity bar) for a handle. */}
+        <Panel id="sessions" panelRef={sidePanelRef} groupResizeBehavior="preserve-pixel-size" collapsible collapsedSize={0} defaultSize={info.sideWidth} minSize={narrow ? 0 : SIDE_MIN} maxSize={SIDE_MAX} className="pmw-frame__side-panel" hidden={narrow && pane !== 'sessions'}>
+          <div className="pmw-frame__sidebar" data-pmw-slot="sidebar" data-shown={(narrow ? pane === 'sessions' : sideShown) || undefined}>{sidebar}</div>
+        </Panel>
+        {sideShown && <Separator className="pmw-frame__handle" data-side="side" aria-label={t.resize} />}
+        <Panel id="centre" minSize={narrow ? 0 : 200} className="pmw-frame__centre-panel" hidden={narrow && (pane === 'sessions' || pane === 'conversation') && panel === null}>
+          <main id="pmw-centre" className="pmw-frame__centre" aria-label={documentTitle ?? t.centre}>{centre}</main>
+        </Panel>
+        {!narrow && info.isRightbarOpen && !info.isRightbarFullscreen && geometry.track > 0 && (
+          <>
+            <Separator className="pmw-frame__handle" data-side="rightbar" aria-label={t.resize} />
+            <Panel id="rightbar" groupResizeBehavior="preserve-pixel-size" defaultSize={geometry.track} minSize={RIGHTBAR_MIN} maxSize="70%"><div className="pmw-frame__rightbar-track" ref={rightbarTrack} /></Panel>
+          </>
+        )}
+        {!narrow && info.isConversationOpen && <Separator className="pmw-frame__handle" data-side="conversation" aria-label={t.resize} />}
+        <Panel id="conversation" panelRef={conversationPanel} groupResizeBehavior="preserve-pixel-size" collapsible collapsedSize={0} defaultSize={info.conversationWidth} minSize={narrow ? 0 : CONVERSATION_MIN} maxSize={narrow ? '100%' : CONVERSATION_MAX} hidden={narrow && pane !== 'conversation'}>
+          <aside className="pmw-frame__conversation" aria-label={t.conversation} data-pmw-slot="main:conversation" data-shown={narrow ? pane === 'conversation' || undefined : info.isConversationOpen || undefined} hidden={!narrow && !info.isConversationOpen}>
+            {conversation}
+          </aside>
+        </Panel>
+      </Group>
+      <div className="pmw-frame__rightbar pmw-frame__rightbar-overlay" data-pmw-slot="rightbar" style={info.isRightbarFullscreen ? { right: 0, width: geometry.viewport } : rightbarBox ?? { right: geometry.conversation, width: geometry.track }}>{rightbar}</div>
+
+      <div className="pmw-frame__bottom" data-pmw-slot="shell.bottom">{bottom}</div>
+      <div className="pmw-frame__overlay" data-pmw-slot="shell.overlay">{overlays}</div>
+
+      <PmDialog open={helpOpen} label={t.help} closeLabel={t.close} onClose={() => setHelpOpen(false)}>
+        <ul className="pmw-help">{t.helpItems.map(item => <li key={item}>{item.replace('{undo}', SHORTCUTS.undo).replace('{redo}', SHORTCUTS.redo)}</li>)}</ul>
+      </PmDialog>
+    </div>
+  )
+}
+
+interface AppBarProps {
+  workbench: Workbench
+  info: LayoutState['layoutInfo']
+  actions: LayoutActions
+  activePanel: string | null
+  globalPanels: RootLayoutOptions['globalPanels']
+  pane: NarrowPane
+  narrow: boolean
+  openSettings(): void
+  openHelp(): void
+}
+
+/**
+ * The bar across the top, as an editor has: the brand and where the author is (the documents, the open document or a
+ * global panel), then operations waiting for the author's approval, the AI assistant, more (plugins, automation), settings and help. On a narrow screen the places
+ * are the panes it switches between.
+ */
+function AppBar({ workbench, info, actions, activePanel, globalPanels, pane, narrow, openSettings, openHelp }: AppBarProps) {
+  const t = useClientMessages(workbench)
+  const document_ = useWorkbenchState(state => state.document)
+  const documentTitle = useWorkbenchState(state => state.documents?.documents.find(doc => doc.dir === state.document)?.title)
+  const working = useWorkbenchState(state => Boolean(state.review?.running))
+  const panels = useSyncExternalStore(globalPanels.subscribe, globalPanels.getSnapshot)
+  const chatShown = narrow ? pane === 'conversation' || pane === 'sessions' : info.isConversationOpen
+  const more = panels.map(({ options }) => ({ id: options.id!, label: typeof options.label === 'function' ? options.label() : options.label ?? options.id! }))
+  const panelLabel = activePanel === null ? undefined : more.find(item => item.id === activePanel)?.label
+  const atDocuments = activePanel === null && (narrow ? pane === 'documents' : document_ === undefined)
+  const atDocument = activePanel === null && document_ !== undefined && (!narrow || pane === 'preview')
+
+  const showDocuments = () => {
+    actions.selectPanel(null)
+    workbench.closeDocument()
+    if (narrow) actions.showNarrowPane('documents')
+  }
+  const showDocument = () => {
+    actions.selectPanel(null)
+    if (narrow) actions.showNarrowPane('preview')
+  }
+  const toggleAssistant = () => {
+    if (narrow) actions.showNarrowPane(chatShown ? (document_ === undefined ? 'documents' : 'preview') : 'conversation')
+    else actions.setConversationOpen(!info.isConversationOpen)
+  }
+
+  return (
+    <nav className="pmw-appbar" aria-label={t.activity}>
+      <span className="pmw-appbar__brand"><Logo /><span className="pmw-brand-name">{t.product}</span></span>
+      <ol className="pmw-appbar__places">
+        <li>
+          <button type="button" className="pmw-appbar__place" data-activity="documents" title={t.documents} aria-current={atDocuments ? 'page' : undefined} onClick={showDocuments}>
+            <PmIcon name="folder" /><span className="pmw-appbar__label">{t.documents}</span>
+          </button>
+        </li>
+        {document_ !== undefined && (
+          <li>
+            <button type="button" className="pmw-appbar__place pmw-appbar__title" data-activity="document" title={documentTitle ?? t.document} aria-current={atDocument ? 'page' : undefined} onClick={showDocument}>
+              <PmIcon name="document" /><span className="pmw-appbar__label">{documentTitle ?? t.document}</span>
+            </button>
+          </li>
+        )}
+        {panelLabel && <li><span className="pmw-appbar__place" aria-current="page"><span className="pmw-appbar__label">{panelLabel}</span></span></li>}
+      </ol>
+      <span className="pmw-spacer" />
+      <span className="pmw-appbar__approvals" data-activity="approvals"><WorkbenchApprovals density={narrow ? 'touch' : 'compact'} /></span>
+      <button type="button" className="pmw-appbar__button pmw-appbar__assistant" data-activity="assistant" title={t.assistant} aria-pressed={chatShown} onClick={toggleAssistant}>
+        <PmIcon name="sparkle" /><span className="pmw-appbar__label">{t.assistant}</span>
+        {working && <span className="pmw-appbar__busy" aria-hidden="true" />}
+      </button>
+      <span className="pmw-appbar__divider" aria-hidden="true" />
+      {more.length > 0 && (
+        <span className="pmw-appbar__more" data-activity="more">
+          <PmMenu label={t.more} items={more} onSelect={(id) => {
+            actions.selectPanel(activePanel === id ? null : id)
+            if (narrow) actions.showNarrowPane('documents')
+          }} />
+        </span>
+      )}
+      <button type="button" className="pmw-appbar__button" data-activity="settings" aria-label={t.settings} title={t.settings} onClick={openSettings}><PmIcon name="sliders" /></button>
+      <button type="button" className="pmw-appbar__button" data-activity="help" aria-label={t.help} title={t.help} onClick={openHelp}><PmIcon name="help" /></button>
+    </nav>
+  )
+}

package/src/client/agent-requests.ts

@@ -0,0 +1,64 @@
+import { selectedDocument } from '@lincyaw/workbench'
+import type { AgentAnswer, Workbench } from '@lincyaw/workbench'
+import type { AssistantSetup } from './assistant-setup.tsx'
+import { mainViewAgentSession, postDocumentContext } from './document-context.ts'
+import { CLIENT_MESSAGES } from './messages.ts'
+
+/**
+ * Lets the workbench hand requests to the main view's agent session: the author's "Rewrite with AI" and comments, and
+ * the repair of the selected document's diagnostics. Each is prompted on the session after its document context is
+ * set, and the conversation is shown. Without a usable model nothing is sent: the conversation is shown, where the
+ * composer offers to set one up, and the request answers with that in the author's terms.
+ */
+export function registerAgentRequests(ctx: DshClientContext, workbench: Workbench, setup: AssistantSetup): void {
+  ctx.inject(['sessions', 'layout'], inner => inner.effect(() => {
+    let active: DshSessionBinding | undefined
+    let offRequests: (() => void) | undefined
+    const update = () => {
+      const row = mainViewAgentSession(inner.sessions.list.getSnapshot().byId)
+      const binding = row && inner.sessions.binding(row.id)
+      if (binding === active) return
+      offRequests?.()
+      offRequests = undefined
+      active = binding
+      if (!row || !binding) return
+      const id = row.id
+      const t = () => CLIENT_MESSAGES[workbench.state.locale]
+      const prompt = async (document: string | null, text: string): Promise<AgentAnswer> => {
+        const isCurrent = () => active === binding && inner.sessions.binding(id) === binding
+          && mainViewAgentSession(inner.sessions.list.getSnapshot().byId)?.id === id
+          && selectedDocument(workbench.state) === document
+        if (document === null || !isCurrent()) throw new Error(t().repairStale)
+        if (setup.readiness.getSnapshot() === 'missing') {
+          inner.layout.selectPanel(null)
+          throw new Error(t().needsModelRequest)
+        }
+        const response = await postDocumentContext(id, document)
+        if (!response.ok) throw new Error(await response.text() || `HTTP ${response.status}`)
+        if (!isCurrent()) throw new Error(t().repairStale)
+        const submission = binding.session.beginSubmission({ mode: 'queue', text, attachments: [] })
+        try {
+          const result = await binding.session.prompt([{ type: 'text', text }], 'queue', undefined, submission.requestId)
+          if (!result.ok) throw new Error(result.error.message)
+          inner.layout.selectPanel(null)
+          return { session: id, request: submission.requestId }
+        } catch (error) {
+          submission.abandon()
+          throw error
+        }
+      }
+      const offRepair = workbench.onRepairDiagnostics(async (diagnostics) => {
+        const document = selectedDocument(workbench.state)
+        if (diagnostics.some(diagnostic => diagnostic.document !== document)) throw new Error(t().repairStale)
+        const text = `${t().repairRequest}\n${JSON.stringify(diagnostics.slice(0, 20))}`
+        const answer = await prompt(document, text)
+        workbench.telemetry.record('agent.ask', { 'presmium.document': document ?? undefined, 'presmium.ask.kind': 'repair', 'presmium.ask.text': text, 'presmium.outcome': 'sent', 'dsh.session.id': answer.session, 'dsh.request.id': answer.request })
+      })
+      const offAsk = workbench.onAgentRequest(request => prompt(selectedDocument(workbench.state), request.text))
+      offRequests = () => { offRepair(); offAsk() }
+    }
+    const off = inner.sessions.list.subscribe(update)
+    update()
+    return () => { off(); offRequests?.() }
+  }, 'presmium: hand the author\'s requests to the current session'))
+}

package/src/client/assistant-setup.tsx

@@ -0,0 +1,185 @@
+import { PmButton, PmIcon, WorkbenchProvider } from '@lincyaw/workbench'
+import type { Workbench } from '@lincyaw/workbench'
+import { ASSISTANT_SLOTS, MODEL_SETTINGS } from './contract.ts'
+import { useClientMessages } from './messages.ts'
+import type { ClientMessages } from './messages.ts'
+import { createObservable } from './observable.ts'
+import { openModelSettings } from './settings-opener.ts'
+
+/** Whether the AI assistant has a model it can run on: unknown until Harness's model catalog has answered. */
+export type AssistantReadiness = 'unknown' | 'ready' | 'missing'
+
+/** Harness's model catalog (`session/modelCatalog`), as far as it is read here. */
+interface ModelCatalogAnswer {
+  ok: boolean
+  value?: { routableProviders?: readonly string[] }
+}
+
+/** The end of a failed turn, as the `turn-error` chat node carries it. */
+interface TurnErrorNode {
+  location?: { turn?: { end?: { data?: { reason?: { kind?: string, error?: { message?: string, code?: string } } } } } }
+}
+
+/** Author-facing kinds of a failed turn, by the failure's stable code. */
+type FailureKind = 'needsModel' | 'keyRejected' | 'quota' | 'busy' | 'tooLong' | 'stopped' | 'other'
+
+const FAILURES: Record<string, FailureKind> = {
+  MISSING_CREDENTIAL: 'needsModel',
+  NO_ADAPTER: 'needsModel',
+  AUTH: 'keyRejected',
+  INVALID_CREDENTIAL: 'keyRejected',
+  QUOTA: 'quota',
+  ACCOUNT_QUOTA: 'quota',
+  RATE_LIMIT: 'busy',
+  OVERLOADED: 'busy',
+  CONTEXT_WINDOW_EXCEEDED: 'tooLong',
+}
+
+/** The kinds whose recovery is in Settings → Models. */
+const SETUP_KINDS = new Set<FailureKind>(['needsModel', 'keyRejected', 'quota'])
+
+function failureOf(node: TurnErrorNode | undefined): { kind: FailureKind, message?: string, code?: string } {
+  const reason = node?.location?.turn?.end?.data?.reason
+  const error = reason?.error
+  if (reason && reason.kind !== 'error') return { kind: 'stopped', message: error?.message, code: error?.code }
+  return { kind: (error?.code && FAILURES[error.code]) || 'other', message: error?.message, code: error?.code }
+}
+
+function failureCopy(t: ClientMessages, kind: FailureKind): { title: string, body: string } {
+  switch (kind) {
+    case 'needsModel': return { title: t.needsModelTitle, body: t.needsModelTurn }
+    case 'keyRejected': return { title: t.keyRejectedTitle, body: t.keyRejected }
+    case 'quota': return { title: t.quotaTitle, body: t.quota }
+    case 'busy': return { title: t.turnFailedTitle, body: t.busy }
+    case 'tooLong': return { title: t.turnFailedTitle, body: t.tooLong }
+    case 'stopped': return { title: t.turnStoppedTitle, body: t.turnStopped }
+    case 'other': return { title: t.turnFailedTitle, body: t.turnFailed }
+  }
+}
+
+/**
+ * Keeps an author from sending a request the AI cannot run, and says in their terms why a turn failed.
+ *
+ * Readiness comes from Harness's model catalog: with no routable provider (no model set up, or no key for any) every
+ * turn would fail, so the composer is taken over by a notice whose one action opens Settings → Models. The editor stays
+ * mounted beneath the takeover, so a request typed before it appeared is still there afterwards. Failed turns are shown
+ * with author copy (and the setup action where the fix is in Models) instead of the provider's diagnostic, which stays
+ * behind a disclosure.
+ */
+export function registerAssistantSetup(ctx: DshClientContext, workbench: Workbench): AssistantSetup {
+  const readiness = createObservable<AssistantReadiness>('unknown')
+  let refresh = () => {}
+
+  ctx.inject(['remote', 'remote.session'], inner => inner.effect(() => {
+    let generation = 0
+    let disposed = false
+    const load = () => {
+      const current = ++generation
+      void inner.remote.session.modelCatalog().then((answer: ModelCatalogAnswer) => {
+        if (disposed || current !== generation || !answer.ok) return
+        const next = answer.value?.routableProviders?.length ? 'ready' : 'missing'
+        if (next !== readiness.getSnapshot()) readiness.set(next)
+      }, () => {})
+    }
+    refresh = load
+    load()
+    const offs = MODEL_SETTINGS.events.map(name => inner.on(name, load))
+    const whileMissing = () => {
+      if (readiness.getSnapshot() !== 'ready') load()
+    }
+    window.addEventListener('focus', load)
+    const timer = window.setInterval(whileMissing, MODEL_SETTINGS.pollMs)
+    return () => {
+      disposed = true
+      refresh = () => {}
+      for (const off of offs) off()
+      window.removeEventListener('focus', load)
+      window.clearInterval(timer)
+    }
+  }, 'presmium: the assistant\'s model readiness'))
+
+  // Before the settings shell has offered `openSection`, the app bar's own Settings button opens Settings.
+  const openModels = () => {
+    if (!openModelSettings()) document.querySelector<HTMLElement>('[data-activity="settings"]')?.click()
+  }
+
+  const [composer, chatNode] = ASSISTANT_SLOTS
+  ctx.effect(() => ctx.slots.inject(composer, () => {
+    let takeover: (() => void) | undefined
+    const update = () => {
+      const missing = readiness.getSnapshot() === 'missing'
+      if (missing && !takeover) {
+        takeover = ctx.slots.register({ name: composer, select: () => MISSING }, () => <NeedsModel workbench={workbench} openModels={openModels} />)
+      } else if (!missing && takeover) {
+        takeover()
+        takeover = undefined
+      }
+    }
+    update()
+    const off = readiness.subscribe(update)
+    return () => {
+      off()
+      takeover?.()
+    }
+  }), 'presmium: the composer explains a missing model')
+
+  ctx.effect(() => ctx.slots.inject(chatNode.name, () => ctx.slots.register({ name: chatNode.name, key: chatNode.key, priority: -1 }, ({ node }: { node?: TurnErrorNode }) => (
+    <TurnFailure workbench={workbench} node={node} openModels={openModels} />
+  ))), 'presmium: failed turns in the author\'s terms')
+
+  return { readiness, refresh: () => refresh(), openModels }
+}
+
+export interface AssistantSetup {
+  readiness: { getSnapshot(): AssistantReadiness, subscribe(listener: () => void): () => void }
+  refresh(): void
+  openModels(): void
+}
+
+const MISSING = Object.freeze({ reason: 'no-model' })
+
+function NeedsModel({ workbench, openModels }: { workbench: Workbench, openModels(): void }) {
+  const t = useClientMessages(workbench)
+  return (
+    <WorkbenchProvider workbench={workbench}>
+      <div className="pmw-assistant-setup pm-ui" role="status" data-pmw-assistant-setup="needs-model">
+        <span className="pmw-assistant-setup__icon"><PmIcon name="sliders" /></span>
+        <div className="pmw-assistant-setup__copy">
+          <p className="pmw-assistant-setup__title">{t.needsModelTitle}</p>
+          <p>{t.needsModel}</p>
+        </div>
+        <div className="pmw-assistant-setup__actions">
+          <PmButton variant="primary" onClick={openModels}>{t.models}</PmButton>
+        </div>
+      </div>
+    </WorkbenchProvider>
+  )
+}
+
+function TurnFailure({ workbench, node, openModels }: { workbench: Workbench, node?: TurnErrorNode, openModels(): void }) {
+  const t = useClientMessages(workbench)
+  const failure = failureOf(node)
+  const copy = failureCopy(t, failure.kind)
+  return (
+    <WorkbenchProvider workbench={workbench}>
+      <div className="pmw-turn-failure pm-ui" role="status" data-pmw-turn-failure={failure.kind}>
+        <span className="pmw-turn-failure__mark" aria-hidden="true"><PmIcon name="warning" /></span>
+        <div className="pmw-turn-failure__copy">
+          <p className="pmw-turn-failure__title">{copy.title}</p>
+          <p>{copy.body}</p>
+          {SETUP_KINDS.has(failure.kind) && (
+            <div className="pmw-turn-failure__actions">
+              <PmButton small onClick={openModels}>{failure.kind === 'needsModel' ? t.models : t.checkModels}</PmButton>
+            </div>
+          )}
+          {(failure.message || failure.code) && (
+            <details className="pmw-turn-failure__details">
+              <summary>{t.failureDetails}</summary>
+              <p>{[failure.message, failure.code].filter(Boolean).join(' · ')}</p>
+            </details>
+          )}
+        </div>
+      </div>
+    </WorkbenchProvider>
+  )
+}

package/src/client/author-settings.ts

@@ -0,0 +1,57 @@
+import { AUTHOR_DEFAULTS, TECHNICAL_SETTINGS } from './contract.ts'
+
+const Hidden = () => null
+
+/**
+ * Gives an author the workbench's defaults for Harness's display preferences and keeps Harness's technical rows out of
+ * Settings → General.
+ *
+ * The defaults are saved through Harness's settings forms, in the profile's own layer, for each field the author has not
+ * chosen yet; a launch patch would outrank that layer and make the forms refuse the author's later choices.
+ *
+ * While the coding view (`ui-settings.enabled`) is off, each technical row is shadowed by an empty cell under its own id,
+ * the slots' public way to replace a shipped cell. Turning the coding view on removes the shadows and the rows come back.
+ */
+export function registerAuthorSettings(ctx: DshClientContext): void {
+  ctx.inject(['configForms'], inner => {
+    for (const [namespace, defaults] of Object.entries(AUTHOR_DEFAULTS)) {
+      inner.effect(() => inner.configForms.whileServed([namespace], () => {
+        const form = inner.configForms.get(namespace)
+        let seeded = false
+        const seed = () => {
+          const snapshot = form.getSnapshot()
+          if (seeded || snapshot.status !== 'ready' || !snapshot.writable || snapshot.revision === undefined) return
+          seeded = true
+          const chosen = (snapshot.user ?? {}) as Record<string, unknown>
+          void (async () => {
+            for (const [field, value] of Object.entries(defaults)) {
+              if (!(field in chosen)) await form.set(field, value).catch(() => false)
+            }
+          })()
+        }
+        const off = form.subscribe(seed)
+        seed()
+        return off
+      }), `presmium: author defaults for ${namespace}`)
+    }
+    const { slot, ids } = TECHNICAL_SETTINGS
+    inner.effect(() => inner.slots.inject(slot, () => {
+      const enabled = inner.configForms.developerTools.enabled
+      let shadows: (() => void)[] = []
+      const update = () => {
+        if (enabled.getSnapshot()) {
+          for (const shadow of shadows) shadow()
+          shadows = []
+        } else if (!shadows.length) {
+          shadows = ids.map(id => inner.slots.register({ name: slot, id, priority: -1 }, Hidden))
+        }
+      }
+      update()
+      const off = enabled.subscribe(update)
+      return () => {
+        off()
+        for (const shadow of shadows) shadow()
+      }
+    }), 'presmium: technical settings behind the coding view')
+  })
+}