@things-factory/ai-assistant 10.1.79 → 10.1.87

package/client/components/assistant-chat.ts

@@ -61,7 +61,7 @@ import {
  */
 import { chatDefaults } from './chat-defaults.js'
 import { isDifferentConversation, resolveConversation, type AssistantMode, type AssistantModeView, pickInitialMode } from './assistant-mode.js'
-import { parseProposalOutcomeLine, type ParsedProposalOutcome } from './proposal-outcome-line.js'
+import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState, type ParsedProposalOutcome } from './proposal-outcome-line.js'
 import { availableTriggers, type TriggerChip } from './chat-triggers.js'
 
 interface ChatLine {
@@ -280,6 +280,7 @@ const CHAT_MESSAGES_QUERY = gql`
       content
       relatedPatchId
       toolUsagesJson
+      proposalsJson
       groundingWarningsJson
       attachmentsJson
       createdAt
@@ -302,6 +303,7 @@ const CHAT_MESSAGE_SUBSCRIPTION = gql`
       content
       relatedPatchId
       toolUsagesJson
+      proposalsJson
       groundingWarningsJson
       attachmentsJson
       createdAt
@@ -802,6 +804,14 @@ export class OxAssistantChat extends LitElement {
   @state()
   private busy = false
 
+  /** Host navigation may retain a conversation for reading while its subject is off screen. */
+  @property() sendBlocked = ''
+
+  /** The host may inspect navigation risk without reading or copying the person's input. */
+  get navigationState(): { busy: boolean; draft: boolean } {
+    return { busy: this.busy, draft: !!this.input.trim() || this.attachments.length > 0 }
+  }
+
   @state()
   private errorMessage?: string
 
@@ -2900,6 +2910,8 @@ export class OxAssistantChat extends LitElement {
           const prevSameSender = !!prev && prev.role === 'user' && prev.senderEmail === line.senderEmail
           const showSenderLabel = isOther && !prevSameSender
           const content = (line.content ?? '').trim()
+          /* A "requested" row is the card's state, shown on the card - as a line it would only be the machine's key. */
+          if (line.role === 'system' && parseProposalRequestLine(content)) return nothing
           /*
            * 가려진 줄은 어시스턴트의 말이 아니다 — 마크다운으로 그리지 않고, 복사·재실행 같은 손잡이도
            * 달지 않는다(ADR-0073 판정 1). 그 손잡이들은 있지도 않은 답을 다룬다.
@@ -3145,9 +3157,9 @@ export class OxAssistantChat extends LitElement {
               `
             : nothing}
           <button
-            ?disabled=${this.busy || (!this.input.trim() && this.attachments.length === 0)}
+            ?disabled=${this.busy || !!this.sendBlocked || (!this.input.trim() && this.attachments.length === 0)}
             @click=${this.send}
-            title=${i18next.t('ai-assistant.text.send-tooltip')}>
+            title=${this.sendBlocked || i18next.t('ai-assistant.text.send-tooltip')}>
             ${this.busy
               ? html`<span class="spinner"></span>`
               : html`<md-icon>arrow_upward</md-icon>`}
@@ -3930,11 +3942,15 @@ export class OxAssistantChat extends LitElement {
   private renderProposals(line: ChatLine) {
     const items = line.proposals ?? []
     if (items.length === 0) return nothing
+    /* The card's state is the conversation's rows - read once for every card of this line. */
+    const outcomes = this.proposalOutcomes
+    const requested = this.proposalRequests
     return html`
       <div class="proposals">
         ${items.map(p => {
           const key = this.proposalKey(p)
-          const sent = this.sentProposals.has(key)
+          const card = proposalCardState(key, { outcomes, requested, sentHere: this.sentProposals.has(key) })
+          const sent = card.state !== 'ready'
           /*
             Follow-up chips are the host's words, never this component's. The fallback that used
             to live here named a 3D modeller's operations in hardcoded Korean, and it reached the
@@ -3956,14 +3972,23 @@ export class OxAssistantChat extends LitElement {
                   the one action the card exists for became unreachable while the model kept
                   telling people to press it.
                 */ ''}
-              <button
-                class="run"
-                ?disabled=${sent}
-                @click=${() => this.executeProposal(p, key)}>
-                ${sent
-                  ? this.proposalStateText(key)
-                  : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
-              </button>
+              ${card.state === 'unconfirmed'
+                ? html`
+                    <span class="preason">${i18next.t('ai-assistant.text.proposal-unconfirmed', { defaultValue: 'sent earlier - no answer received' })}</span>
+                    <button class="run" @click=${() => this.checkProposal(p, key)}>
+                      ${i18next.t('ai-assistant.button.check-proposal', { defaultValue: 'check result' })}
+                    </button>
+                  `
+                : html`
+                    <button
+                      class="run"
+                      ?disabled=${sent}
+                      @click=${() => this.executeProposal(p, key)}>
+                      ${sent
+                        ? this.proposalStateText(key)
+                        : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
+                    </button>
+                  `}
               ${/*
                   Drawn only where the host has said it staged this candidate, in the host's own
                   words. Not knowing is not a claim: with no word from the host, nothing is drawn.
@@ -4120,10 +4145,34 @@ export class OxAssistantChat extends LitElement {
 
   private elapsedTimer?: ReturnType<typeof setInterval>
 
-  private executeProposal(p: any, key: string) {
+  private async executeProposal(p: any, key: string) {
+    if (this.sentProposals.has(key)) return
     this.sentProposals = new Set(this.sentProposals).add(key)
     this.proposalSentAt.set(key, Date.now())
     this._startElapsedTicker()
+
+    /*
+     * The server records the request first and answers whether this conversation has taken the proposal
+     * already (ADR-0097 Q-D4 ④). Only a granted request reaches the host. A refused one - taken in another
+     * window, or before a refresh - leaves the card to the rows; a failed one leaves it as it was, and the
+     * error is said by the client's own error line. Either way the host is not asked.
+     */
+    if (this.sessionId) {
+      let granted = false
+      try {
+        granted = await this.requestProposal(key)
+      } catch {
+        granted = false
+      }
+      if (!granted) {
+        const left = new Set(this.sentProposals)
+        left.delete(key)
+        this.sentProposals = left
+        this.proposalSentAt.delete(key)
+        return
+      }
+    }
+
     this.dispatchEvent(
       new CustomEvent('assistant-proposal-execute', {
         /*
@@ -4137,6 +4186,44 @@ export class OxAssistantChat extends LitElement {
     )
   }
 
+  private async requestProposal(key: string): Promise<boolean> {
+    const result = await client.mutate({
+      mutation: gql`
+        mutation ($id: String!, $key: String!) {
+          requestProposal(sessionId: $id, proposalKey: $key)
+        }
+      `,
+      variables: { id: this.sessionId, key }
+    })
+    if (result.errors?.length) throw new Error(result.errors[0].message)
+    return result.data?.requestProposal === true
+  }
+
+  /**
+   * "Check result" on a card that was requested and never answered: the host is asked what happened
+   * (`AssistantSurface.proposalOutcome`), never to run it again. The dock reports what it learns.
+   */
+  private checkProposal(p: any, key: string) {
+    this.dispatchEvent(
+      new CustomEvent('assistant-proposal-check', {
+        detail: { proposal: p, sessionId: this.sessionId, proposalKey: key },
+        bubbles: true,
+        composed: true
+      })
+    )
+  }
+
+  /** Keys whose run was requested - from the conversation's rows, like the outcomes. */
+  private get proposalRequests(): Set<string> {
+    const requested = new Set<string>()
+    for (const line of this.lines) {
+      if (line.role !== 'system') continue
+      const key = parseProposalRequestLine(line.content ?? '')
+      if (key) requested.add(key)
+    }
+    return requested
+  }
+
   /**
    * 호스트가 무엇을 했는지 — 대화에 남은 `system` 행에서 읽는다(ADR-0070 A12-a 결정 ①).
    *
@@ -4447,6 +4534,7 @@ export class OxAssistantChat extends LitElement {
   }
 
   private async send() {
+    if (this.sendBlocked) { this.errorMessage = this.sendBlocked; return }
     const text = this.input.trim()
     const attachmentsToSend = [...this.attachments]
     if ((!text && attachmentsToSend.length === 0) || this.busy) return
@@ -4508,6 +4596,7 @@ export class OxAssistantChat extends LitElement {
         modelFingerprint: assistantModelFingerprint(liveBoard) }
     } catch (error) {
       this.errorMessage = error instanceof Error ? error.message : String(error)
+      this.attachments = attachmentsToSend
       return
     }
 

package/client/components/assistant-dock.ts

@@ -31,6 +31,7 @@ import {
 } from '../utils/assistant-surface.js'
 import { runProposal, type ProposalContext, type ProposalOutcome } from '../utils/assistant-proposals.js'
 import { holdAssistantAsk, subscribeAssistantAsk, takeAssistantAsk, type AssistantAsk } from '../utils/assistant-ask.js'
+import { surfaceTransition } from '../utils/assistant-navigation.js'
 
 export const ASSISTANT_DOCK_VIEWPART = 'assistant-dock'
 
@@ -159,6 +160,34 @@ export class AssistantDock extends localize(i18next)(LitElement) {
         --md-icon-size: 18px;
       }
 
+      /*
+       * An open conversation is read by everyone in the domain - the dock says so on every screen of it, not
+       * only in the list (2026-09-30: open and private were one grey word apart, and an owner's question about
+       * the books sat in every employee's list). A private one draws nothing extra: it is the default.
+       */
+      :host([audience='open']) {
+        border-left: 3px solid var(--md-sys-color-tertiary);
+      }
+
+      .audience {
+        display: flex;
+        align-items: center;
+        gap: 6px;
+        flex: none;
+        padding: 6px 10px;
+        background: var(--md-sys-color-tertiary-container);
+        color: var(--md-sys-color-on-tertiary-container);
+        border-bottom: 1px solid var(--md-sys-color-tertiary);
+        font-size: 12px;
+        font-weight: 600;
+        line-height: 1.35;
+      }
+
+      .audience md-icon {
+        --md-icon-size: 16px;
+        flex: none;
+      }
+
       ox-assistant-session-toolbar {
         flex: none;
         min-width: 0;
@@ -191,6 +220,35 @@ export class AssistantDock extends localize(i18next)(LitElement) {
         gap: 4px;
         font: inherit;
       }
+
+      .next-step {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 10px;
+        padding: 8px 12px;
+        border-bottom: 1px solid var(--md-sys-color-outline-variant);
+        background: var(--md-sys-color-surface-container-low);
+        color: var(--md-sys-color-on-surface-variant);
+        font-size: 12px;
+        line-height: 1.4;
+      }
+
+      .next-step a {
+        display: inline-flex;
+        align-items: center;
+        gap: 3px;
+        flex: none;
+        color: var(--md-sys-color-primary);
+        font-weight: 650;
+        text-decoration: none;
+      }
+
+      .next-step a:hover { text-decoration: underline; }
+      .next-step md-icon { --md-icon-size: 16px; }
+      ox-assistant-chat[hidden] { display: none; }
+      .transition { padding: 10px 12px; font-size: 13px; line-height: 1.5; border-bottom: 1px solid var(--md-sys-color-outline-variant); background: var(--md-sys-color-surface-container-low); }
+      .transition button { display: block; margin-top: 6px; font: inherit; }
     `
   ]
 
@@ -211,6 +269,9 @@ export class AssistantDock extends localize(i18next)(LitElement) {
   @state() private showingHistory = false
   @state() private conversationView = 0
   @state() private asking?: { ask?: string; draft?: string; requestId: string }
+  @state() private screenChanged = false
+  @state() private navigationNotice = ''
+  private openedIdentity = ''
 
   private app = new AppController(this)
   /** The kind the person picked; kept while the surface stays the same. */
@@ -237,11 +298,24 @@ export class AssistantDock extends localize(i18next)(LitElement) {
 
   private onStartNewSession = () => void this.newConversation()
 
+  /** Who reads the open conversation - absent until the list or the create answer says. */
+  private get audience(): string | undefined {
+    return this.sessions.find(session => session.id === this.sessionId)?.visibility || undefined
+  }
+
+  protected updated(changed: Map<PropertyKey, unknown>) {
+    super.updated?.(changed as any)
+    const audience = !this.showingHistory && this.audience === 'open' ? 'open' : null
+    if (audience) this.setAttribute('audience', audience)
+    else this.removeAttribute('audience')
+  }
+
   connectedCallback() {
     super.connectedCallback()
     this.addEventListener('assistant-start-new-session', this.onStartNewSession)
     this.unsubscribers.push(
       subscribeAssistantSurface(() => this.follow()),
+      store.subscribe(() => { if (this.openedIdentity !== this.identityKey()) this.follow() }),
       subscribeAssistantAsk(() => void this.takeAsk()),
       subscribeSessionActivity(activity => {
         /* A rename or a new conversation elsewhere on this anchor - the tabs read again. */
@@ -260,24 +334,75 @@ export class AssistantDock extends localize(i18next)(LitElement) {
     super.disconnectedCallback()
   }
 
-  private scopeKey(surface = this.surface) {
+  private scopeKey(surface: AssistantSurface | undefined) {
     return JSON.stringify([this.app.contextPath, surface?.key ?? ''])
   }
 
+  private identityKey() {
+    const user = (store.getState() as any).auth?.user
+    return JSON.stringify([this.app.contextPath, user?.id || user?.email || ''])
+  }
+
+  private get navigationState() {
+    return (this.renderRoot.querySelector('ox-assistant-chat') as any)?.navigationState ?? { busy: false, draft: false }
+  }
+
+  private async mayLeaveConversation(): Promise<boolean> {
+    if (this.navigationState.busy) {
+      notify({ level: 'info', message: t('wait-before-switch', 'Wait for the current response before changing conversations.') })
+      return false
+    }
+    if (!this.navigationState.draft) return true
+    const identity = this.identityKey()
+    const accepted = await OxPrompt.open({
+      type: 'warning', title: t('switch-title', 'Change conversation?'),
+      text: t('switch-draft', 'Your unsent text and attachments will not move to the other conversation.'),
+      confirmButton: { text: t('switch-confirm', 'Discard draft and switch') },
+      cancelButton: { text: t('stay', 'Keep writing') }
+    })
+    return !!accepted && identity === this.identityKey()
+  }
+
+  private async requestSurface(surface: AssistantSurface | undefined) {
+    if (!(await this.mayLeaveConversation())) return
+    this.chosenKind = ''
+    this.surface = surface
+    this.navigationNotice = surface ? t('now-about', 'Conversation subject: {name}', { name: surface.label() }) : ''
+    await this.open()
+  }
+
   /** The screen changed - a different surface or domain is a different conversation. */
   private follow(force = false) {
     const next = currentAssistantSurface()
-    if (!force && next === this.surface && this.scopeKey(next) === this.openedFor) {
-      /* The same conversation, told that its words changed - a name loaded, a board renamed on save. */
+    const transition = surfaceTransition({
+      identityChanged: this.openedIdentity !== this.identityKey(),
+      sameSubject: this.scopeKey(next) === this.openedFor,
+      active: isAnchor(this.anchor) && (!!this.sessionId || this.navigationState.draft || this.navigationState.busy)
+    })
+    if (!force && transition === 'refresh') {
+      this.surface = next
+      this.screenChanged = false
       this.requestUpdate()
       return
     }
+    if (!force && transition === 'offer') {
+      this.screenChanged = true
+      return
+    }
+    if (transition === 'reset') {
+      this.asking = undefined
+      this.capability = 'unknown'
+      if (this.openedIdentity) takeAssistantAsk()
+    }
+    this.navigationNotice = transition === 'follow' && next ? t('now-about', 'Conversation subject: {name}', { name: next.label() }) : ''
     if (next?.key !== this.surface?.key) this.chosenKind = ''
     this.surface = next
     void this.open()
   }
 
   private async open(): Promise<void> {
+    this.openedIdentity = this.identityKey()
+    this.screenChanged = false
     const ticket = ++this.revision
     this.conversationView++
     this.showingHistory = false
@@ -285,7 +410,7 @@ export class AssistantDock extends localize(i18next)(LitElement) {
     this.loading = true
     this.failure = ''
     this.anchor = undefined
-    this.openedFor = this.scopeKey()
+    this.openedFor = this.scopeKey(this.surface)
 
     try {
       if (this.capability !== 'configured') {
@@ -341,13 +466,15 @@ export class AssistantDock extends localize(i18next)(LitElement) {
 
   private async newConversation() {
     if (this.loading || !isAnchor(this.anchor)) return
+    if (!(await this.mayLeaveConversation())) return
     this.showingHistory = false
     const revision = this.controller.state.revision
     await this.controller.reset()
     if (revision !== this.controller.state.revision) this.conversationView++
   }
 
-  private selectSession(id: string, pickedKind?: string) {
+  private async selectSession(id: string, pickedKind?: string) {
+    if (id !== this.sessionId && !(await this.mayLeaveConversation())) return
     this.showingHistory = false
     const follow = followPickedConversation(pickedKind, this.kind)
     if (follow) {
@@ -360,9 +487,10 @@ export class AssistantDock extends localize(i18next)(LitElement) {
     if (this.controller.select(id) && previous !== id) this.conversationView++
   }
 
-  private onModeChange = (event: CustomEvent) => {
+  private onModeChange = async (event: CustomEvent) => {
     const kind = event.detail?.kind
     if (!kind || kind === this.kind) return
+    if (!(await this.mayLeaveConversation())) return
     this.chosenKind = kind
     void this.open()
   }
@@ -371,6 +499,11 @@ export class AssistantDock extends localize(i18next)(LitElement) {
 
   private async takeAsk() {
     if (this.loading || !this.anchor) return
+    if (this.screenChanged || this.navigationState.busy || this.navigationState.draft) {
+      const waiting = takeAssistantAsk()
+      if (waiting) notify({ level: 'info', message: t('ask-kept-current', 'The current conversation was kept. Switch to the intended subject before asking again.') })
+      return
+    }
     if (!isAnchor(this.anchor)) {
       /*
         A question is not sent later on its own, once some conversation happens to stand - by then the person is looking
@@ -442,6 +575,8 @@ export class AssistantDock extends localize(i18next)(LitElement) {
   /* ── proposals ───────────────────────────────────────────────────────────────────── */
 
   private proposalContext(sessionId?: string): ProposalContext {
+    const identity = this.identityKey()
+    const scope = this.openedFor
     return {
       sessionId,
       surface: this.surface,
@@ -452,7 +587,7 @@ export class AssistantDock extends localize(i18next)(LitElement) {
           text,
           confirmButton: { text: confirmText ?? t('confirm', 'OK') },
           cancelButton: { text: cancelText ?? t('cancel', 'Cancel') }
-        })),
+        })) && identity === this.identityKey() && scope === this.scopeKey(currentAssistantSurface()),
       notify: (level, message) => notify({ level, message })
     }
   }
@@ -476,7 +611,9 @@ export class AssistantDock extends localize(i18next)(LitElement) {
   /** Every proposal ends in exactly one reported outcome - a kind nobody handles is `unavailable`. */
   private onProposal = async (event: CustomEvent) => {
     const { proposal, sessionId, proposalKey } = event.detail ?? {}
-    const outcome = await runProposal(proposal, this.proposalContext(sessionId))
+    const outcome: ProposalOutcome = this.openedFor !== this.scopeKey(currentAssistantSurface()) || this.openedIdentity !== this.identityKey()
+      ? { verdict: 'unavailable', errorCode: 'conversation-screen-changed', note: t('return-to-subject', 'Return to the conversation subject before applying this proposal.') }
+      : await runProposal(proposal, this.proposalContext(sessionId))
     if (outcome.verdict === 'unavailable' && outcome.errorCode === 'unknown-proposal-kind') {
       notify({ level: 'error', message: t('proposal-not-runnable', 'this proposal cannot be run on this screen.') })
     }
@@ -485,6 +622,33 @@ export class AssistantDock extends localize(i18next)(LitElement) {
     if (outcome.note && sessionId) await this.appendNote(sessionId, outcome.note)
   }
 
+  /**
+   * "Check result" - asks the surface what became of a requested proposal and reports only what it learns.
+   * Nothing is run: a lost answer never turns into a second application (ADR-0097 Q-D4 ④).
+   */
+  private onProposalCheck = async (event: CustomEvent) => {
+    const { proposal, sessionId, proposalKey } = event.detail ?? {}
+    const ask = this.surface?.proposalOutcome
+    if (!ask) {
+      notify({ level: 'info', message: t('proposal-result-uncheckable', 'this screen cannot check that result. open the screen where it was applied.') })
+      return
+    }
+
+    let outcome: ProposalOutcome | undefined
+    try {
+      outcome = await ask.call(this.surface, proposalKey, proposal)
+    } catch {
+      outcome = undefined
+    }
+    if (!outcome?.verdict) {
+      notify({ level: 'info', message: t('proposal-result-unknown', 'the result is still unknown. it was not applied again.') })
+      return
+    }
+
+    await this.report(sessionId, proposalKey, outcome)
+    if (outcome.note && sessionId) await this.appendNote(sessionId, outcome.note)
+  }
+
   private async appendNote(sessionId: string, note: string) {
     try {
       await client.mutate({
@@ -503,15 +667,22 @@ export class AssistantDock extends localize(i18next)(LitElement) {
   /* ── board surfaces: the chat's scene edits land on the open board ───────────────── */
 
   private onScenePatch = async (event: CustomEvent) => {
+    if (!this.mayApplyOnScreen()) return
     const board = this.surface?.board
     if (!board) return
     const result = await board.applyPatch(event.detail)
     if (result?.missed) notify({ level: 'info', message: t('patch-missed', '{missed} of the changes could not be applied.', { missed: result.missed }) })
   }
 
-  private onBoardRevert = (event: CustomEvent) => void this.surface?.board?.revertPatch?.(event.detail?.patchId)
+  private mayApplyOnScreen() {
+    if (this.openedFor === this.scopeKey(currentAssistantSurface()) && this.openedIdentity === this.identityKey()) return true
+    notify({ level: 'info', message: t('return-to-subject', 'Return to the conversation subject before applying this proposal.') })
+    return false
+  }
 
-  private onSceneAction = (event: CustomEvent) => void this.surface?.board?.applyAction?.(event.detail)
+  private onBoardRevert = (event: CustomEvent) => { if (this.mayApplyOnScreen()) void this.surface?.board?.revertPatch?.(event.detail?.patchId) }
+
+  private onSceneAction = (event: CustomEvent) => { if (this.mayApplyOnScreen()) void this.surface?.board?.applyAction?.(event.detail) }
 
   /* ── drawing ─────────────────────────────────────────────────────────────────────── */
 
@@ -540,16 +711,16 @@ export class AssistantDock extends localize(i18next)(LitElement) {
               <md-icon>home</md-icon>
             </button>`
           : nothing}
-        ${ready
+        ${ready && this.showingHistory
           ? html`<button
               class="sbtn"
               title=${this.showingHistory ? t('back-to-conversation', 'back to the conversation') : t('conversations', 'conversations')}
               @click=${() => (this.showingHistory = !this.showingHistory)}
             >
-              <md-icon>${this.showingHistory ? 'forum' : 'list'}</md-icon>
+              <md-icon>arrow_back</md-icon>${t('back-to-conversation', 'back to the conversation')}
             </button>`
           : nothing}
-        <button class="sbtn" title=${t('rebind', 'follow this screen again')} @click=${() => this.follow(true)}>
+        <button class="sbtn" title=${t('rebind', 'follow this screen again')} @click=${() => this.requestSurface(currentAssistantSurface())}>
           <md-icon>refresh</md-icon>
         </button>
         <button class="sbtn" title=${t('close', 'close')} @click=${() => closeOverlay(this.viewpart)}>
@@ -561,9 +732,7 @@ export class AssistantDock extends localize(i18next)(LitElement) {
 
   /** The home button: talk about the application instead of this screen, until the screen changes. */
   private useSurface(surface: AssistantSurface) {
-    this.surface = surface
-    this.chosenKind = ''
-    void this.open()
+    void this.requestSurface(surface)
   }
 
   render(): TemplateResult {
@@ -578,6 +747,14 @@ export class AssistantDock extends localize(i18next)(LitElement) {
 
     return html`
       ${this.header()}
+      ${surface?.nextStep ? html`<div class="next-step" role="status">
+        <span>${surface.nextStep.description?.() || ''}</span>
+        <a href=${surface.nextStep.href}>${surface.nextStep.label()}<md-icon>arrow_forward</md-icon></a>
+      </div>` : nothing}
+      ${this.screenChanged ? html`<div class="transition" role="status">
+        ${t('screen-and-conversation', 'Screen: {screen}. Conversation: {conversation}. Your conversation has been kept.', { screen: currentAssistantSurface()?.label() || t('no-subject', 'No subject'), conversation: surface?.label() || '' })}
+        <button class="sbtn" @click=${() => this.requestSurface(currentAssistantSurface())}>${t('switch-to-screen', 'Talk about this screen')}</button>
+      </div>` : this.navigationNotice ? html`<div class="transition" role="status">${this.navigationNotice}</div>` : nothing}
       ${ready && this.showingHistory
         ? html`<ox-assistant-session-manager
             .anchorType=${(anchor as any).anchorType}
@@ -585,6 +762,7 @@ export class AssistantDock extends localize(i18next)(LitElement) {
             .sessionId=${this.sessionId}
             .kind=${this.kind}
             .kindLabels=${this.kindLabels}
+            .scopeLabel=${t('conversation-scope', 'Conversations · {name}', { name: surface?.label() || '' })}
             @assistant-session-select=${(event: CustomEvent) => this.selectSession(event.detail.sessionId, event.detail.kind)}
             @assistant-session-reset=${() => this.newConversation()}
             @assistant-session-changed=${() => this.reloadSessions()}
@@ -597,21 +775,30 @@ export class AssistantDock extends localize(i18next)(LitElement) {
             .loading=${this.loading}
             .error=${this.failure}
             historyEnabled
+            singleConversation
             @assistant-session-select=${(event: CustomEvent) => this.selectSession(event.detail.sessionId)}
             @assistant-session-reset=${() => this.newConversation()}
             @assistant-session-history=${() => (this.showingHistory = true)}
             @assistant-session-retry=${() => this.open()}
           ></ox-assistant-session-toolbar>`
         : nothing}
-      ${ready && !this.showingHistory && !this.loading && !this.failure
+      ${ready && !this.showingHistory && this.audience === 'open'
+        ? html`<div class="audience" role="status">
+            <md-icon>public</md-icon>
+            <span>${t('audience-open-band', 'Public conversation - everyone in this domain can read and write here.')}</span>
+          </div>`
+        : nothing}
+      ${ready && !this.loading && !this.failure
         ? keyed(
             this.conversationView,
             html`<ox-assistant-chat
+              ?hidden=${this.showingHistory}
+              .sendBlocked=${this.screenChanged ? t('return-to-subject', 'Return to the conversation subject before sending or applying changes.') : ''}
               .sessionId=${this.sessionId}
               .prepareSession=${(adopt: (id: string) => void) => this.controller.prepareSession(adopt)}
               .contextProvider=${() => {
                 /* The screen moved on between writing and sending - do not answer about the old one. */
-                if (openedFor !== this.scopeKey(currentAssistantSurface() ?? surface)) throw new Error(t('screen-changed', 'the screen changed while you were writing. send it again.'))
+                if (openedFor !== this.scopeKey(currentAssistantSurface()) || this.openedIdentity !== this.identityKey()) throw new Error(t('return-to-subject', 'Return to the conversation subject before applying this proposal.'))
                 return { hostContext: surface?.hostContext?.() ?? {} }
               }}
               .mode=${mode}
@@ -631,6 +818,7 @@ export class AssistantDock extends localize(i18next)(LitElement) {
               .draftRequestId=${this.asking?.requestId}
               @assistant-mode-change=${this.onModeChange}
               @assistant-proposal-execute=${this.onProposal}
+              @assistant-proposal-check=${this.onProposalCheck}
               @scene-edit-patch=${this.onScenePatch}
               @board-edit-revert=${this.onBoardRevert}
               @scene-action-execute=${this.onSceneAction}

package/client/components/assistant-mode.test.ts

@@ -24,9 +24,13 @@ const MODE_VIEW = {
 }
 
 /** The board product, which declares no mode and names its own door. */
+/*
+ * A host on the neutral door. A board host (`chatEndpoint: 'boardAIChat'`) keeps its own door even with
+ * a mode - it alone carries the board document (16d14bce2b, ADR-0061 decision 0-1) - and is pinned below.
+ */
 const HOST_PROPERTIES = {
   hostContext: { boardId: 'B-1' },
-  chatEndpoint: 'boardAIChat' as const
+  chatEndpoint: 'assistantChat' as const
 }
 
 const GLOBAL_DEFAULTS = {
@@ -70,7 +74,7 @@ describe('a mode names the conversation; the server says what it offers', () =>
 
 describe('a host with no mode', () => {
   test('gets its own properties and the registered defaults, as before modes existed', () => {
-    const c = resolveConversation(undefined, HOST_PROPERTIES, GLOBAL_DEFAULTS)
+    const c = resolveConversation(undefined, { ...HOST_PROPERTIES, chatEndpoint: 'boardAIChat' }, GLOBAL_DEFAULTS)
 
     expect(c.hostContext).toEqual({ boardId: 'B-1' })
     expect(c.slashTemplates).toEqual(GLOBAL_DEFAULTS.slashTemplates)
@@ -145,3 +149,13 @@ describe('followPickedConversation', () => {
     expect(followPickedConversation('', 'figure.modeller')).toBeUndefined()
   })
 })
+
+describe('a board host keeps the board door', () => {
+  test('★ with a mode, the door stays boardAIChat and the board defaults fill what the mode leaves out', () => {
+    const c = resolveConversation(MODE, { ...HOST_PROPERTIES, chatEndpoint: 'boardAIChat' }, GLOBAL_DEFAULTS, undefined)
+
+    expect(c.kind).toBe('twin.space')
+    expect(c.chatEndpoint).toBe('boardAIChat')
+    expect(c.catalogEntries).toEqual(GLOBAL_DEFAULTS.catalogEntries)
+  })
+})