@things-factory/ai-assistant 10.1.212 → 10.1.214

package/client/utils/assistant-ask.ts

@@ -5,6 +5,7 @@
  * header ask box, a performance page carrying its context. The request waits here until the dock takes it,
  * so a dock that is closed (not mounted) still gets it when it opens.
  */
+import type { AssistantSelection } from './assistant-selection.js'
 export interface AssistantAsk {
   /** Sent as the next question. */
   ask?: string
@@ -18,17 +19,50 @@ export interface AssistantAsk {
   transcript?: { role: 'user' | 'ai'; content: string }[]
   /** A note stored first: what the screen was showing when the person asked. */
   context?: string
+  /**
+   * The records the person picked on the screen - a screen request (「AI와 작업」, design/ai/shared-dock.md §2-11-1). It
+   * goes to this screen's conversation, never a new one; the selection is noted for that turn (a line the person reads,
+   * the ids for the model - assistant-selection.ts) and `ask` is sent at once.
+   */
+  selection?: AssistantSelection
+}
+
+/** What became of a request - a screen keeps what the person wrote when it was not sent, and says nothing twice. */
+export interface AssistantAskOutcome {
+  sent: boolean
+  /** Why it was not sent, in the person's words - the dock has already said it. */
+  reason?: string
 }
 
 type Listener = () => void
 
 let pending: AssistantAsk | undefined
 const listeners = new Set<Listener>()
+const settlers = new WeakMap<AssistantAsk, (outcome: AssistantAskOutcome) => void>()
 
-export function askAssistant(ask: AssistantAsk): void {
+/**
+ * Hands the request to the dock. The promise says what became of it once the dock has dealt with it - sent, or not and
+ * why. A request replaced before the dock took it is not sent, and says so.
+ */
+export function askAssistant(ask: AssistantAsk): Promise<AssistantAskOutcome> {
+  if (pending && pending !== ask) settleAssistantAsk(pending, { sent: false, reason: 'replaced' })
+  const outcome = new Promise<AssistantAskOutcome>(resolve => settlers.set(ask, resolve))
   pending = ask
   listeners.forEach(listener => listener())
   window.dispatchEvent(new CustomEvent('assistant-dock-open'))
+  return outcome
+}
+
+/** The dock tells the screen what became of its request. Once; later calls do nothing. */
+export function settleAssistantAsk(ask: AssistantAsk, outcome: AssistantAskOutcome): void {
+  const settle = settlers.get(ask)
+  settlers.delete(ask)
+  settle?.(outcome)
+}
+
+/** The waiting request, left waiting - the dock decides how to take it before taking it. */
+export function peekAssistantAsk(): AssistantAsk | undefined {
+  return pending
 }
 
 /**

package/client/utils/assistant-proposals.ts

@@ -37,6 +37,29 @@ export function proposalHandlerOf(tool: string | undefined): ProposalHandler | u
   return tool ? handlers.get(tool) : undefined
 }
 
+/**
+ * How a package's card is drawn in the conversation, besides the framework's line: an element drawn under it (given
+ * `proposal`, `sessionId` and `proposalKey`), and the words of its button. A dashboard card draws its preview as the
+ * one looking at the conversation (ADR-0160 decision 6). Registered by the package that declares the tool.
+ */
+export interface ProposalView {
+  /** A custom element's tag name - defined by the registering package. */
+  previewTag?: string
+  /** i18n key of the button, and its words when the key has none. */
+  runLabelKey?: string
+  runLabel?: string
+}
+
+const views = new Map<string, ProposalView>()
+
+export function registerProposalView(tool: string, view: ProposalView): void {
+  views.set(tool, view)
+}
+
+export function proposalViewOf(tool: string | undefined): ProposalView | undefined {
+  return tool ? views.get(tool) : undefined
+}
+
 /*
  * Data entry cards are the framework's, whatever record they enter (design/ai/data-entry.md §5): one
  * handler asks the server to enter the stored rows. The dock sets it; no app registers one per record.

package/client/utils/assistant-selection.test.ts

@@ -0,0 +1,54 @@
+import { noteForDisplay, selectedRecords, selectionLabel, selectionNote, SELECTION_KEYS_PREFIX, SELECTION_ROW_PICKER } from './assistant-selection'
+
+const t = (_key: string, defaultValue: string, options: any = {}) => defaultValue.replace(/\{(\w+)\}/g, (_, name) => String(options[name]))
+const contract = (id: string, label: string) => ({ id, label })
+
+describe('the records picked on a screen, as a note', () => {
+  it('★ the person reads a line of names; the model reads the list and the ids', () => {
+    const note = selectionNote({ title: '계약 대장', list: 'contracts', records: [contract('c-1', 'H2022019 · 브라이스톤 IT3.0 Website')] }, t)
+    expect(note).toBe(`Selected 1 · 계약 대장: H2022019 · 브라이스톤 IT3.0 Website\n${SELECTION_KEYS_PREFIX} contracts c-1`)
+    expect(note).not.toMatch(/[{}"]|explicit-page-selection/)
+  })
+
+  it('★ the screen draws the person\'s line only', () => {
+    const note = selectionNote({ title: '계약 대장', list: 'contracts', records: [contract('c-1', 'H2022019')] }, t)
+    expect(noteForDisplay(note)).toBe('Selected 1 · 계약 대장: H2022019')
+    expect(noteForDisplay('a plain note\nsecond line')).toBe('a plain note\nsecond line')
+  })
+
+  it('every id reaches the model; the names are cut after a few, the rest counted', () => {
+    const records = Array.from({ length: 7 }, (_, i) => contract(`c-${i}`, `C${i}`))
+    const note = selectionNote({ title: 'L', records }, t)
+    expect(note.split('\n')[0]).toBe('Selected 7 · L: C0, C1, C2, C3, C4 and 2 more')
+    expect(note.split('\n')[1]).toBe(`${SELECTION_KEYS_PREFIX} ${records.map(one => one.id).join(' ')}`)
+  })
+
+  it('a record picked twice is one; nothing picked is no note', () => {
+    expect(selectionNote({ title: 'L', records: [contract('a', 'A'), contract('a', 'A')] }, t)).toBe(`Selected 1 · L: A\n${SELECTION_KEYS_PREFIX} a`)
+    expect(selectionNote({ title: 'L', records: [] }, t)).toBe('')
+  })
+})
+
+describe('the rows a list hands over (ox-assistant-selection-bar)', () => {
+  it('★ each row goes as the key its list\'s read tool takes - `<axis>:<uuid>`', () => {
+    expect(selectedRecords([{ id: 'u1', code: 'H1', name: 'A' }], { axis: 'contract' })).toEqual([{ id: 'contract:u1', label: 'H1 · A' }])
+    expect(selectedRecords([{ id: 'u1', name: 'A' }])).toEqual([{ id: 'u1', label: 'A' }])
+  })
+
+  it('saved rows only, each once, in screen order; never the whole row', () => {
+    const row = { id: 'a', number: 'INV-1', title: 'T', bankDetails: 'secret' }
+    const records = selectedRecords([row, row, { id: 'b', __dirty__: 'M', name: 'B' }, { name: 'no id' }, { id: 'c', name: 'C' }])
+    expect(records).toEqual([{ id: 'a', label: 'INV-1 · T' }, { id: 'c', label: 'C' }])
+    expect(JSON.stringify(records)).not.toMatch(/secret/)
+  })
+
+  it('a screen may say a row in its own words', () => {
+    expect(selectedRecords([{ id: 'q', number: 'Q-7', version: 2 }], { labelOf: row => `${row.number} v${row.version}` })).toEqual([{ id: 'q', label: 'Q-7 v2' }])
+    expect(selectionLabel({ code: 'C', description: 'D' })).toBe('C · D')
+    expect(selectionLabel({})).toBe('')
+  })
+
+  it('the row picker is the grid\'s own, many at once', () => {
+    expect(SELECTION_ROW_PICKER).toEqual({ type: 'gutter', gutterName: 'row-selector', multiple: true })
+  })
+})

package/client/utils/assistant-selection.ts

@@ -0,0 +1,74 @@
+/*
+ * The records a person picked on a screen and handed to the assistant - `askAssistant({ selection })`.
+ *
+ * The conversation keeps them as a note: one line the person reads (「선택 1건 · 계약 대장: H2022019 · 브라이스톤 IT3.0
+ * Website」) and one line the model reads - the list and the ids, after `[keys]`. The screen hides the key line; the
+ * model is handed the note as stored. Until 2026-10-24 the screen sent the selection as JSON and the conversation
+ * opened on `{"source":"explicit-page-selection",…}`.
+ */
+
+/**
+ * The grid's own row picker - a list that hands its rows to the assistant shows it beside `ox-assistant-selection-bar`
+ * (data-grist gutter `row-selector`, many at once).
+ */
+export const SELECTION_ROW_PICKER = { type: 'gutter', gutterName: 'row-selector', multiple: true }
+
+/** A picked row as the person reads it, when the screen gives no words of its own - its code or number, then its name. */
+export function selectionLabel(row: any): string {
+  return [row?.code || row?.number, row?.name || row?.title || row?.description]
+    .filter(Boolean)
+    .join(' · ')
+}
+
+/**
+ * The rows a person picked, as the assistant is handed them (`askAssistant({ selection })`): saved rows only (an id, no
+ * pending edit), each once, in screen order - never whole rows. Given the list's axis, each id is the record's key
+ * `<axis>:<uuid>`, the one that list's read tool takes (read-target.ts `recordIdOfKey`): a bare uuid names no tool, and
+ * a model read a contract's id with a dashboard's card tool (2026-10-25, Office 미수금).
+ */
+export function selectedRecords(rows: any[], options: { axis?: string; labelOf?: (row: any) => string } = {}): { id: string; label: string }[] {
+  const { axis, labelOf = selectionLabel } = options
+  const seen = new Set<string>()
+  return (rows ?? [])
+    .filter(row => row?.id && !row.__dirty__ && !seen.has(row.id) && !!seen.add(row.id))
+    .map(row => ({ id: axis ? `${axis}:${row.id}` : row.id, label: labelOf(row) || '' }))
+}
+
+/** The line the model reads begins with this; the conversation does not draw it. */
+export const SELECTION_KEYS_PREFIX = '[keys]'
+
+/** Labels named on the person's line - the rest are counted. */
+export const SELECTION_LABELS_SHOWN = 5
+
+export interface AssistantSelection {
+  /** The list the records were picked from, as the person knows it (「계약 대장」). */
+  title: string
+  /** The list's query (`contracts`) - which list the ids belong to, for the model. */
+  list?: string
+  records: { id: string; label?: string }[]
+}
+
+export type SelectionTranslate = (key: string, defaultValue: string, options?: Record<string, unknown>) => string
+
+/** The note stored in the conversation - the person's line, then the key line. Empty when nothing was picked. */
+export function selectionNote(selection: AssistantSelection, t: SelectionTranslate): string {
+  const seen = new Set<string>()
+  const records = (selection?.records ?? []).filter(one => one?.id && !seen.has(one.id) && !!seen.add(one.id))
+  if (!records.length) return ''
+  const labels = records.map(one => (one.label || '').replace(/\s+/g, ' ').trim()).filter(Boolean)
+  const shown = labels.slice(0, SELECTION_LABELS_SHOWN).join(', ')
+  const rest = labels.length - Math.min(labels.length, SELECTION_LABELS_SHOWN)
+  const line = t('selection-note', 'Selected {count} · {title}', { count: records.length, title: selection.title })
+  const named = shown ? `${line}: ${shown}${rest > 0 ? ` ${t('selection-more', 'and {count} more', { count: rest })}` : ''}` : line
+  const keys = `${SELECTION_KEYS_PREFIX} ${selection.list ? `${selection.list} ` : ''}${records.map(one => one.id).join(' ')}`
+  return `${named}\n${keys}`
+}
+
+/** A note as the conversation draws it - without the line only the model reads. */
+export function noteForDisplay(content: string): string {
+  return (content ?? '')
+    .split('\n')
+    .filter(line => !line.startsWith(SELECTION_KEYS_PREFIX))
+    .join('\n')
+    .trim()
+}

package/client/utils/assistant-session-controller.ts

@@ -13,6 +13,8 @@ export interface AssistantSession {
   kind?: string
   /** Who reads it: 'open' (everyone in the domain), 'group' (the people the owner brought in) or 'private' (the owner alone). The dock draws an open one apart. */
   visibility?: string
+  /** Whether this person sits in it - `false` for someone else's open conversation the dock showed; absent on one just made. */
+  participant?: boolean
 }
 export interface AssistantSessionTarget {
   /** Account/domain boundary supplied by the authenticated host. */

package/client/utils/assistant-session-transport.ts

@@ -20,7 +20,7 @@ export const assistantSessionTransport: AssistantSessionTransport = {
        * Every readable conversation of this kind on the anchor, not only mine - the same scope the manager
        * shows by default (design/ai/shared-dock.md §2-6). Without a kind: every kind, as before.
        */
-      query: gql`query($type:String!,$id:String!,$kind:String){chatSessionInbox(anchorType:$type,anchorId:$id,kind:$kind,limit:100){id name kind visibility}}`,
+      query: gql`query($type:String!,$id:String!,$kind:String){chatSessionInbox(anchorType:$type,anchorId:$id,kind:$kind,limit:100){id name kind visibility participant}}`,
       variables: { type: target.anchorType, id: target.anchorId, kind: target.kind || null }, fetchPolicy: 'no-cache'
     })
     if (result.errors?.length) throw new Error(result.errors[0].message)

package/client/utils/invite-proposal-register.ts

@@ -0,0 +1,31 @@
+/*
+ * Pressing an invite card seats the person through the invite door, as the one who pressed (ADR-0073 decision 3).
+ * The card is ai-assistant's own tool (server: people/invite-tools.ts), so its handler is registered here, by the
+ * package that declared it - the dock knows no proposal kind (design/ai/shared-dock.md §4).
+ */
+import gql from 'graphql-tag'
+
+import { i18next } from '@operato/i18n'
+import { client } from '@operato/graphql'
+
+import { registerProposalHandler } from './assistant-proposals.js'
+import { inviteProposalHandler } from './invite-proposal.js'
+
+registerProposalHandler(
+  'proposeInvite',
+  inviteProposalHandler(
+    async (sessionId, userIds) => {
+      const result = await client.mutate({
+        mutation: gql`
+          mutation ($id: String!, $users: [String!]!) {
+            inviteToAISession(sessionId: $id, userIds: $users)
+          }
+        `,
+        variables: { id: sessionId, users: userIds }
+      })
+      if (result.errors?.length) throw new Error(result.errors[0].message)
+      return result.data?.inviteToAISession ?? []
+    },
+    (key, options) => String(i18next.t(key, options))
+  )
+)

package/client/utils/invite-proposal.test.ts

@@ -0,0 +1,40 @@
+import { inviteProposalHandler, invitedBy, isInviteProposal } from './invite-proposal'
+
+const card = (people: any[], extra: any = {}) => ({ tool: 'proposeInvite', kind: 'invite', people, ...extra })
+const kim = { userId: 'u-1', name: '정연희', department: 'Sales' }
+const lee = { userId: 'u-2', name: '정연희', department: 'Finance' }
+const t = (_key: string, options: any) => String(options.defaultValue).replace('{names}', options.names)
+const context = (sessionId?: string) => ({ sessionId, confirm: async () => true, notify: () => {} }) as any
+
+describe('the invite card', () => {
+  it('is the invite tool\'s card with someone on it', () => {
+    expect(isInviteProposal(card([kim]))).toBe(true)
+    expect(isInviteProposal(card([]))).toBe(false)
+    expect(isInviteProposal({ ...card([kim]), tool: 'proposeAction' })).toBe(false)
+  })
+
+  it('★ one person: pressing invites them; several: only the one picked - nothing is guessed', () => {
+    expect(invitedBy(card([kim]))).toEqual([kim])
+    expect(invitedBy(card([kim, lee]))).toEqual([])
+    expect(invitedBy(card([kim, lee], { chosen: 'u-2' }))).toEqual([lee])
+  })
+
+  it('★ pressing calls the invite door with the conversation and the person picked', async () => {
+    const calls: any[] = []
+    const handler = inviteProposalHandler(async (sessionId, userIds) => (calls.push([sessionId, userIds]), userIds), t)
+    expect(await handler(card([kim, lee], { chosen: 'u-2' }), context('s1'))).toMatchObject({ verdict: 'accepted', applied: 1, note: '정연희 joined this conversation and was told.' })
+    expect(calls).toEqual([['s1', ['u-2']]])
+  })
+
+  it('no pick, no conversation, or nobody seated - said, never accepted', async () => {
+    const handler = inviteProposalHandler(async (_s, userIds) => userIds, t)
+    expect(await handler(card([kim, lee]), context('s1'))).toEqual({ verdict: 'refused', errorCode: 'no-person-chosen' })
+    expect(await handler(card([kim]), context())).toEqual({ verdict: 'unavailable', errorCode: 'no-conversation' })
+    expect(await inviteProposalHandler(async () => [], t)(card([kim]), context('s1'))).toEqual({ verdict: 'refused', errorCode: 'already-here' })
+  })
+
+  it("the door's refusal is not swallowed - it is thrown to the dock, which reports it", async () => {
+    const handler = inviteProposalHandler(async () => { throw new Error('only the person who started this group conversation can bring people in.') }, t)
+    await expect(handler(card([kim]), context('s1'))).rejects.toThrow(/only the person who started/)
+  })
+})

package/client/utils/invite-proposal.ts

@@ -0,0 +1,54 @@
+/*
+ * The invite card (server: people/invite-tools.ts) - who it offers, and what pressing it does.
+ *
+ * Pressing is the person's act: the dock calls `inviteToAISession` with their own request, and the door decides
+ * whether they may seat anyone here (`maySeat`). The model's card seats nobody by itself. A card with several people
+ * of one name is pressed on one of them - the press carries `chosen`; nothing is guessed.
+ */
+import type { ProposalHandler } from './assistant-proposals.js'
+
+export interface InvitePerson {
+  userId: string
+  name: string
+  department?: string
+  position?: string
+}
+
+export function isInviteProposal(proposal: any): boolean {
+  return proposal?.kind === 'invite' && proposal?.tool === 'proposeInvite' && Array.isArray(proposal?.people) && proposal.people.length > 0
+}
+
+/** The people a press brings in: the one picked, or the only one on the card. */
+export function invitedBy(proposal: any): InvitePerson[] {
+  const people: InvitePerson[] = Array.isArray(proposal?.people) ? proposal.people.filter((one: any) => one?.userId) : []
+  if (proposal?.chosen) return people.filter(one => one.userId === proposal.chosen)
+  return people.length === 1 ? people : []
+}
+
+/** One line under a person's name - where they work. */
+export function personLine(person: InvitePerson): string {
+  return [person.department, person.position].filter(Boolean).join(' · ')
+}
+
+/**
+ * Presses the card through the invite door. `invite` is the door - `inviteToAISession(sessionId, userIds)`, answering the
+ * ids seated now; it throws the door's refusal, which the dock reports as `refused` with that message.
+ */
+export function inviteProposalHandler(
+  invite: (sessionId: string, userIds: string[]) => Promise<string[]>,
+  t: (key: string, options: Record<string, unknown>) => string
+): ProposalHandler {
+  return async (proposal, context) => {
+    const people = invitedBy(proposal)
+    if (!people.length) return { verdict: 'refused', errorCode: 'no-person-chosen' }
+    if (!context.sessionId) return { verdict: 'unavailable', errorCode: 'no-conversation' }
+    const seated = await invite(context.sessionId, people.map(one => one.userId))
+    if (!seated.length) return { verdict: 'refused', errorCode: 'already-here' }
+    const names = people.filter(one => seated.includes(one.userId)).map(one => one.name).join(', ')
+    return {
+      verdict: 'accepted',
+      applied: seated.length,
+      note: t('ai-assistant.people.invited', { names, defaultValue: '{names} joined this conversation and was told.' })
+    }
+  }
+}

package/dist-client/components/assistant-chat.d.ts

@@ -309,6 +309,15 @@ export declare class OxAssistantChat extends LitElement {
         text: string;
         attachments: ChatAttachment[];
     }): void;
+    /**
+     * A request made on the screen (「AI와 작업」, design/ai/shared-dock.md §2-11-1) - in this conversation, made now if it
+     * has none yet: the selection's note first, then the request, sent at once. What the person was writing is set aside
+     * while it goes and put back after, whatever happened. Says whether it was sent and, if not, why.
+     */
+    sendScreenRequest(text: string, note: string): Promise<{
+        sent: boolean;
+        reason?: string;
+    }>;
     private errorMessage?;
     /** C4 presence/roster — 세션 참여자 목록. lastSeenAt 으로 online 판정. */
     private participants;
@@ -560,6 +569,15 @@ export declare class OxAssistantChat extends LitElement {
      * 실행 결과는 호스트가 **대화에 기록**한다 — 누가 무엇을 실행했는지가 협의 이력에 남아야 한다.
      */
     private renderProposals;
+    /** A package's preview under its card - the element is the package's; it is handed the proposal and where it is. */
+    private renderProposalPreview;
+    /** One preview element per card, kept across renders so it does not read again on every keystroke. */
+    private proposalPreviews;
+    /**
+     * The invite card. Pressing it is the person's act - the dock calls the invite door with their request. With several
+     * people of one name each is a button with where they work; the press carries whom they picked.
+     */
+    private renderInviteCard;
     /** The screen card - which list, the conditions the screen does not take, and the way to open it. */
     private renderOpenPageCard;
     /** The AI 작업판 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */

package/dist-client/components/assistant-chat.js

@@ -5,6 +5,8 @@ import { rosterName } from './roster-identity';
 import { notify } from '@operato/layout';
 import './assistant-invite.js';
 import { TypingRoom } from '../utils/assistant-typing.js';
+import { isInviteProposal, personLine } from '../utils/invite-proposal.js';
+import { noteForDisplay } from '../utils/assistant-selection.js';
 /**
  * <ox-assistant-chat> — AI 도우미 채팅 컴포넌트 (Lit).
  *
@@ -63,6 +65,7 @@ import './entry-review.js';
 import { entryGroupOf, entryReadyCount, entryTitle, isChangeProposal, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js';
 import { isWorkspaceProposal, versionOfCard, workspaceAddress } from '../utils/workspace.js';
 import { isOpenPageProposal, openPageNote } from '../utils/open-page.js';
+import { proposalViewOf } from '../utils/assistant-proposals.js';
 function formatFileSize(bytes) {
     if (!bytes || bytes < 1024)
         return `${bytes || 0} B`;
@@ -279,6 +282,12 @@ const CHAT_TYPING_SUBSCRIPTION = gql `
     }
   }
 `;
+/* The selection a screen request carries, noted before the request (design/ai/shared-dock.md §2-11-1). */
+const APPEND_SESSION_NOTE_MUTATION = gql `
+  mutation AppendSessionNote($sessionId: String!, $content: String!) {
+    appendSessionNote(sessionId: $sessionId, content: $content)
+  }
+`;
 const TOUCH_PRESENCE_MUTATION = gql `
   mutation TouchPresence($sessionId: String!) {
     touchPresence(sessionId: $sessionId)
@@ -442,6 +451,8 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             this.foldNoticeDismissed = true;
             this.dispatchEvent(new CustomEvent('assistant-start-new-session', { bubbles: true, composed: true }));
         };
+        /** One preview element per card, kept across renders so it does not read again on every keystroke. */
+        this.proposalPreviews = new Map();
         /**
          * 실행은 호스트가 한다 — 이 컴포넌트는 도메인(트윈 명령 채널)을 모른다.
          * 확인 대화·명령 전송·결과 기록은 호스트의 몫이고, 여기서는 중복 클릭만 막는다.
@@ -715,6 +726,47 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         this.input = draft.text;
         this.attachments = draft.attachments;
     }
+    /**
+     * A request made on the screen (「AI와 작업」, design/ai/shared-dock.md §2-11-1) - in this conversation, made now if it
+     * has none yet: the selection's note first, then the request, sent at once. What the person was writing is set aside
+     * while it goes and put back after, whatever happened. Says whether it was sent and, if not, why.
+     */
+    async sendScreenRequest(text, note) {
+        if (this.busy)
+            return { sent: false, reason: i18next.t('ai-assistant.text.screen-request-busy', { defaultValue: 'an answer is still being written.' }) };
+        const kept = this.takeDraft();
+        try {
+            if (!this.sessionId && this.prepareSession) {
+                await this.prepareSession(id => {
+                    this.adoptingSession = true;
+                    this.sessionId = id;
+                });
+                await this.updateComplete;
+            }
+            if (!this.sessionId)
+                return { sent: false, reason: i18next.t('ai-assistant.text.screen-request-no-session', { defaultValue: 'this screen has no conversation to send to.' }) };
+            if (note) {
+                const noted = await client.mutate({ mutation: APPEND_SESSION_NOTE_MUTATION, variables: { sessionId: this.sessionId, content: note } });
+                if (noted.errors?.length)
+                    throw new Error(noted.errors[0].message);
+                await this.loadHistory();
+            }
+            this.errorMessage = undefined;
+            this.input = text;
+            await this.send();
+            return this.errorMessage ? { sent: false, reason: this.errorMessage } : { sent: true };
+        }
+        catch (error) {
+            return { sent: false, reason: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            /* The request is the screen's - it never stays in the box; the box gets back what the person had written. */
+            if (this.input.trim() === text.trim())
+                this.input = '';
+            if (kept && !this.input.trim() && !this.attachments.length)
+                this.restoreDraft(kept);
+        }
+    }
     /** 현재 로그인 사용자 email — 그룹챗에서 내 메시지 vs 타인 메시지 구분.
      *  email 을 쓰는 이유: /auth/profile 이 항상 내려주는 로그인 식별자이고(비어 있지 않다),
      *  내부 관리키(User.id)를 클라이언트 판정에 의존하지 않기 위함. */
@@ -1664,6 +1716,16 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
       --md-icon-size: 13px;
       color: inherit;
     }
+    /* The invite card's people - where each works, quieter than the name; a picked card greys every button. */
+    .proposal-choices .choice-chip .invite-where {
+      margin-left: 4px;
+      opacity: 0.7;
+      font-size: 0.92em;
+    }
+    .proposal-choices .choice-chip:disabled {
+      opacity: 0.5;
+      cursor: default;
+    }
 
     /* The entry card's way to the large review - a quiet action under its table, never a second run button. */
     .workspace-review {
@@ -2924,7 +2986,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                           class="sys-text"
                           title=${i18next.t('ai-assistant.text.toggle-system-note', { defaultValue: 'click to expand' })}
                           @click=${() => this.toggleSystemNote(idx)}
-                          >${content}</span
+                          >${noteForDisplay(content)}</span
                         >`
                                 : content}
                 ${line.attachments && line.attachments.length > 0
@@ -4022,7 +4084,12 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             if (isOpenPageProposal(p))
                 return this.renderOpenPageCard(p);
             const card = proposalCardState(key, { outcomes, requested, sentHere: this.sentProposals.has(key) });
+            /* An invite card: one person, one button; several of one name, one button each - the person picks (ADR-0073 decision 3). */
+            if (isInviteProposal(p))
+                return this.renderInviteCard(p, key, card.state);
             const entry = isEntryProposal(p);
+            /* A package's own card - its preview under the line, its words on the button (assistant-proposals.ts ProposalView). */
+            const view = entry ? undefined : proposalViewOf(p.tool);
             const replaced = entry && latestEntry?.get(entryGroupOf(p)) !== key && card.state === 'ready';
             const ready = entry ? entryReadyCount(p) : 0;
             const sent = card.state !== 'ready' || replaced || (entry && ready === 0);
@@ -4068,7 +4135,9 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                                     ? i18next.t('ai-assistant.entry.change', { defaultValue: 'change {count} records', count: ready })
                                     : i18next.t('ai-assistant.entry.enter', { defaultValue: 'enter {count} rows', count: ready })
                                 : i18next.t('ai-assistant.entry.nothing-to-enter', { defaultValue: 'nothing to enter' })
-                            : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
+                            : view?.runLabelKey || view?.runLabel
+                                ? i18next.t(view.runLabelKey ?? '', { defaultValue: view.runLabel ?? 'run' })
+                                : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
               ${ /*
@@ -4085,6 +4154,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
               ` : nothing}
             </div>
             ${entry ? html `<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
+            ${view?.previewTag ? this.renderProposalPreview(view.previewTag, p, key) : nothing}
             ${entry && this.sessionId && offersWorkspaceReview(p)
                 ? html `<button
                   class="workspace-review"
@@ -4112,6 +4182,51 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
       </div>
     `;
     }
+    /** A package's preview under its card - the element is the package's; it is handed the proposal and where it is. */
+    renderProposalPreview(tag, p, key) {
+        const element = this.proposalPreviews.get(key) ?? document.createElement(tag);
+        this.proposalPreviews.set(key, element);
+        element.proposal = p;
+        element.sessionId = this.sessionId;
+        element.proposalKey = key;
+        return html `${element}`;
+    }
+    /**
+     * The invite card. Pressing it is the person's act - the dock calls the invite door with their request. With several
+     * people of one name each is a button with where they work; the press carries whom they picked.
+     */
+    renderInviteCard(p, key, state) {
+        const people = p.people;
+        const sent = state !== 'ready';
+        const status = sent ? this.proposalStateText(key) : '';
+        return html `
+      <div class="proposal invite ${sent ? 'sent' : ''}">
+        <md-icon>${p.icon || 'person_add'}</md-icon>
+        <span class="pbody">
+          <span class="plabel">${p.label}</span>
+          ${p.reason ? html `<span class="preason">${p.reason}</span>` : nothing}
+          ${sent && people.length > 1 ? html `<span class="preason">${status}</span>` : nothing}
+        </span>
+        ${people.length === 1
+            ? html `<button class="run" ?disabled=${sent} @click=${() => this.executeProposal(p, key)}>
+              ${sent ? status : i18next.t('ai-assistant.button.invite', { defaultValue: 'Invite' })}
+            </button>`
+            : nothing}
+      </div>
+      ${people.length > 1
+            ? html `<div class="proposal-choices invite-people" role="group" aria-label=${p.label}>
+            ${people.map(person => html `<button
+                class="choice-chip"
+                ?disabled=${sent}
+                title=${personLine(person)}
+                @click=${() => this.executeProposal({ ...p, chosen: person.userId }, key)}>
+                <md-icon>person_add</md-icon>
+                <span>${person.name}${personLine(person) ? html ` <span class="invite-where">${personLine(person)}</span>` : nothing}</span>
+              </button>`)}
+          </div>`
+            : nothing}
+    `;
+    }
     /** The screen card - which list, the conditions the screen does not take, and the way to open it. */
     renderOpenPageCard(p) {
         const note = openPageNote(p, (key, options) => String(i18next.t(key, options)));