@things-factory/ai-assistant 10.1.226 → 10.1.227

package/client/components/assistant-chat.ts

@@ -39,12 +39,14 @@ import {
   injectMentionUserIds,
   stripMentionRefids
 } from './markdown.js'
-import { acceptOf, chatAttachmentUrl, refuseAttachments, textCharsOf } from '../utils/attachment-policy.js'
+import { acceptOf, chatAttachmentUrl, limitsOf, refuseAttachments, textCharsOf } from '../utils/attachment-policy.js'
 import { fileUploadLimits } from '@operato/utils/file-acceptance.js'
 import '@operato/input/ox-input-file.js'
 import { pastedTableFile } from '../utils/pasted-table.js'
 import { appendWords, composerHeight, composerKeyAction, composerSuggestion, sendShortcut, tableAsWords } from '../utils/composer-frame.js'
 import { readSpreadsheet, spreadsheetKindOf, type SpreadsheetRefusal } from '../utils/spreadsheet-text.js'
+import { documentKindOf, readDocx, readPdf, readPptx, type DocumentRefusal } from '../utils/document-text.js'
+import { drawPdfPage, loadPdfjs } from '../utils/pdf-pages.js'
 import { entryReviewAddress, offersWorkspaceReview } from '../utils/entry-workspace.js'
 import { buildAssistantChatInput, buildChatMutationInput } from './chat-input-builder.js'
 import { agentDetail, offersAgentPicker, pickAgentId, rememberAgent, rememberedAgent, type AgentChoice } from '../utils/agent-choice.js'
@@ -703,6 +705,15 @@ export class OxAssistantChat extends LitElement {
       }
       list = read.files
     }
+    if (this.usesAttachmentPolicy && this.modeView?.attachments?.kinds?.includes('document')) {
+      /* A PDF, .docx or .pptx travels as its text with its page and slide numbers, a scanned page as an image (§9-6). */
+      const read = await this.readDocuments(list)
+      if ('refusal' in read) {
+        this.errorMessage = String(i18next.t(`ai-assistant.text.${read.refusal.code}`, { ...(read.refusal as any), defaultValue: read.refusal.code }))
+        return
+      }
+      list = read.files
+    }
     if (this.usesAttachmentPolicy) {
       /* Said before anything is sent - never cut silently (§9-1). The one picking rule, the server's upload limit included. */
       const refusal = refuseAttachments(
@@ -763,6 +774,43 @@ export class OxAssistantChat extends LitElement {
     return { files: out }
   }
 
+  /** Each document replaced by its text, and a PDF's scanned pages by their images; any other file passes as it is. */
+  private async readDocuments(list: File[]): Promise<{ files: File[] } | { refusal: DocumentRefusal }> {
+    const policy = this.modeView?.attachments
+    const maxChars = textCharsOf(policy)
+    const out: File[] = []
+    for (const file of list) {
+      const kind = documentKindOf(file)
+      if (!kind) {
+        out.push(file)
+        continue
+      }
+      if (kind === 'doc' || kind === 'ppt') return { refusal: { code: 'attachment-old-office-not-read', name: file.name } }
+      const data = await file.arrayBuffer()
+      let read
+      if (kind === 'pdf') {
+        const pdfjs = await loadPdfjs()
+        let pdf: any
+        read = await readPdf(
+          async () => (pdf = await pdfjs.getDocument({ data }).promise),
+          file.name,
+          maxChars,
+          /* The text travels as one file; the scans may take the rest of what one message carries. */
+          { allowed: !!policy?.kinds?.includes('image'), max: Math.max(0, limitsOf(policy).maxFiles! - 1) },
+          number => drawPdfPage(pdf, number)
+        )
+      } else {
+        const mod: any = await import('jszip')
+        const zip = mod.default ?? mod
+        read = kind === 'docx' ? await readDocx(data, file.name, maxChars, zip) : await readPptx(data, file.name, maxChars, zip)
+      }
+      if ('refusal' in read) return { refusal: read.refusal }
+      out.push(new File([read.files.text.text], read.files.text.name, { type: 'text/plain' }))
+      for (const image of read.files.images) out.push(new File([image.blob], image.name, { type: 'image/jpeg' }))
+    }
+    return { files: out }
+  }
+
   private readFileAsBase64(file: File): Promise<string> {
     return new Promise((resolve, reject) => {
       const reader = new FileReader()
@@ -4690,7 +4738,7 @@ export class OxAssistantChat extends LitElement {
     `
   }
 
-  /** The AI 작업판 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */
+  /** The AI 작업 패널 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */
   private renderWorkspaceCard(p: any, key: string) {
     const { version, of } = versionOfCard(this.lines.map(one => one.proposals ?? []), p.workspace.name, key)
     const contents = Object.entries(p.contents ?? {})

package/client/components/assistant-dock.ts

@@ -331,7 +331,7 @@ export class AssistantDock extends localize(i18next)(LitElement) {
   private onStartNewSession = () => void this.newConversation()
 
 
-  /* A card asks for a page of this application - the AI 작업판. The dock stays open beside it. */
+  /* A card asks for a page of this application - the AI 작업 패널. The dock stays open beside it. */
   private onOpenPage = (event: CustomEvent) => {
     const href = event.detail?.href
     if (typeof href === 'string' && href) navigate(href)

package/client/components/assistant-mode.ts

@@ -54,7 +54,7 @@ export interface AssistantModeView {
   footerNotice?: string
   stagedNotice?: string
   /** What this conversation accepts as attachments; absent - none (design/ai/shared-dock.md §9-1). */
-  attachments?: { kinds: ('image' | 'text' | 'spreadsheet')[]; maxBytes?: number; maxFiles?: number; maxChars?: number }
+  attachments?: { kinds: ('image' | 'text' | 'spreadsheet' | 'document')[]; maxBytes?: number; maxFiles?: number; maxChars?: number }
 }
 
 /** True when these two describe different conversations, so the old one should be closed. */

package/client/components/entry-review.ts

@@ -178,7 +178,7 @@ export class AssistantEntryReview extends LitElement {
       color: var(--md-sys-color-primary);
     }
 
-    /* In the AI 작업판: every row, the page's height, the reading size of a page (design/ai/workspace.md §6-1). */
+    /* In the AI 작업 패널: every row, the page's height, the reading size of a page (design/ai/workspace.md §6-1). */
     :host([wide]) {
       font-size: 13px;
     }
@@ -205,7 +205,7 @@ export class AssistantEntryReview extends LitElement {
   ]
 
   @property({ attribute: false }) proposal: any
-  /** The 작업판's review - every row is drawn, not the first fifty. */
+  /** The 작업 패널's review - every row is drawn, not the first fifty. */
   @property({ type: Boolean, reflect: true }) wide = false
 
   /** The sum of each totalled field, beside the total the material prints - a missing row shows here without reading every row. */

package/client/components/workspace-view.ts

@@ -1,5 +1,5 @@
 /*
- * The blocks of an AI 작업판, drawn (operato-application/design/ai/workspace.md §3).
+ * The blocks of an AI 작업 패널, drawn (operato-application/design/ai/workspace.md §3).
  *
  * Every kind is drawn here - the model writes no HTML. Charts use the eight validated categorical colours in
  * a fixed order (dataviz reference palette, light and dark each checked); three of the light ones sit under

package/client/index.ts

@@ -20,7 +20,7 @@ export * from './components/assistant-dock.js'
 export * from './setup-assistant-dock.js'
 export * from './utils/assistant-surface.js'
 export * from './utils/assistant-proposals.js'
-/* The AI 작업판's blocks, drawn - also a dashboard card's (ADR-0160 decision 5). */
+/* The AI 작업 패널's blocks, drawn - also a dashboard card's (ADR-0160 decision 5). */
 export * from './components/workspace-view.js'
 export * from './utils/assistant-ask.js'
 export * from './utils/assistant-selection.js'

package/client/pages/assistant-workspace-page.ts

@@ -1,5 +1,5 @@
 /*
- * The AI 작업판 page (operato-application/design/ai/workspace.md).
+ * The AI 작업 패널 page (operato-application/design/ai/workspace.md).
  *
  * `assistant-workspace?session=<id>&name=<name>[&version=<n>]`, or `?session=<id>&entry=<proposal key>` to review a
  * 입력안 wide (§6-1) - read only; the card in the dock is where it is entered. It reads the conversation through its own

package/client/route.ts

@@ -1,7 +1,7 @@
 /* The pages ai-assistant brings to every application that installs it. */
 export default function route(page: string) {
   switch (page) {
-    /* The AI 작업판 - results too large for the dock (design/ai/workspace.md). */
+    /* The AI 작업 패널 - results too large for the dock (design/ai/workspace.md). */
     case 'assistant-workspace':
       import('./pages/assistant-workspace-page.js')
       return page

package/client/utils/attachment-policy.ts

@@ -11,11 +11,14 @@
  */
 import { narrowLimits, sortPickedFiles, type FileUploadLimits } from '@operato/utils/file-acceptance.js'
 
+import { DOCUMENT_ACCEPT } from './document-text.js'
+
 /*
- * 'spreadsheet' is a kind a mode opens, never a file the door receives: the screen reads each .xlsx sheet into CSV
- * text before sending (client/utils/spreadsheet-text.ts), so a mode that takes spreadsheets takes that text.
+ * 'spreadsheet' and 'document' are kinds a mode opens, never files the door receives: the screen reads each .xlsx
+ * sheet into CSV text (spreadsheet-text.ts), and each PDF, .docx and .pptx into text (document-text.ts) before
+ * sending, so a mode that takes them takes that text - and a scanned PDF page as an image.
  */
-export type AttachmentKind = 'image' | 'text' | 'spreadsheet'
+export type AttachmentKind = 'image' | 'text' | 'spreadsheet' | 'document'
 
 export interface AttachmentPolicy {
   kinds: AttachmentKind[]
@@ -38,9 +41,13 @@ const XLSX_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.s
 const KIND_ACCEPT: Record<AttachmentKind, string[]> = {
   image: ['image/*'],
   text: [...TEXT_EXTENSIONS, ...TEXT_TYPES],
-  spreadsheet: ['.xlsx', XLSX_TYPE]
+  spreadsheet: ['.xlsx', XLSX_TYPE],
+  document: DOCUMENT_ACCEPT
 }
 
+/** The kinds that are read into text on the screen - they arrive as text. */
+const READ_INTO_TEXT: AttachmentKind[] = ['spreadsheet', 'document']
+
 /** A kind the policy takes - text also when it takes spreadsheets, which arrive as the text of their sheets. */
 const acceptFor = (kinds: AttachmentKind[]) => [...new Set(kinds.flatMap(kind => KIND_ACCEPT[kind]))].join(',')
 
@@ -73,8 +80,8 @@ export function refuseAttachments(
   if (!files.length) return null
   if (!policy || !policy.kinds?.length) return { code: 'attachments-not-accepted' }
 
-  /* What is sent: a spreadsheet arrives as the text of its sheets. */
-  const sent = policy.kinds.map(kind => (kind === 'spreadsheet' ? 'text' : kind))
+  /* What is sent: a spreadsheet or a document arrives as its text. */
+  const sent = policy.kinds.map(kind => (READ_INTO_TEXT.includes(kind) ? 'text' : kind))
   const limits = narrowLimits(limitsOf(policy), server)
   const { refused } = sortPickedFiles(files, { accept: acceptFor(sent), limits })
   if (!refused.length) return null
@@ -86,10 +93,10 @@ export function refuseAttachments(
     : { code: 'attachment-too-large', name: first.file.name || '', maxBytes: limits.maxFileSize! }
 }
 
-/** The file picker's `accept` for a policy - a spreadsheet as the person picks it (.xlsx). */
+/** The file picker's `accept` for a policy - a spreadsheet or a document as the person picks it (.xlsx, .pdf, ...). */
 export function acceptOf(policy: AttachmentPolicy | null | undefined): string {
   const kinds = policy?.kinds ?? []
-  return acceptFor(kinds.includes('spreadsheet') ? [...kinds, 'text'] : kinds)
+  return acceptFor(kinds.some(kind => READ_INTO_TEXT.includes(kind)) ? [...kinds, 'text'] : kinds)
 }
 
 /** Where a conversation's file opens - the gated route, under the page's domain path. */

package/client/utils/document-text.ts

@@ -0,0 +1,332 @@
+/*
+ * A document read into text the conversation can carry (design/ai/shared-dock.md §9-6) - PDF, Word (.docx) and
+ * PowerPoint (.pptx), as a spreadsheet is (spreadsheet-text.ts): the door takes images and text only, so a mode that
+ * opens 'document' has the screen read the file before sending (2026-10-28, the user: 「pdf, word, ppt 파일은 처리할
+ * 수 없는가?」).
+ *
+ * - Every page and slide is marked with its own number, so an answer can say "page 3" or "slide 5" and be checked.
+ * - A PDF page with no text on it is a scan: it is drawn into an image and sent beside the text, named by its page.
+ * - The old binary .doc and .ppt are refused by name, as .xls is - nothing here opens them.
+ * - The limit is on the text after reading. A document over it is refused, never cut: a cut contract is read as the
+ *   whole contract.
+ * - Word keeps no pages (they are laid out when printed), so a .docx is read in order with its headings marked.
+ */
+
+export type DocumentKind = 'pdf' | 'docx' | 'pptx' | 'doc' | 'ppt'
+
+const PDF_TYPE = 'application/pdf'
+const DOCX_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+const PPTX_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+const DOC_TYPE = 'application/msword'
+const PPT_TYPE = 'application/vnd.ms-powerpoint'
+
+/** The picker's `accept` for documents. */
+export const DOCUMENT_ACCEPT = ['.pdf', PDF_TYPE, '.docx', DOCX_TYPE, '.pptx', PPTX_TYPE]
+
+/** A document by its type, or by its name when the browser did not know the type. */
+export function documentKindOf(file: { type?: string; name?: string }): DocumentKind | null {
+  const type = (file.type || '').toLowerCase()
+  const name = (file.name || '').toLowerCase()
+  if (type === PDF_TYPE || name.endsWith('.pdf')) return 'pdf'
+  if (type === DOCX_TYPE || name.endsWith('.docx')) return 'docx'
+  if (type === PPTX_TYPE || name.endsWith('.pptx')) return 'pptx'
+  if (type === DOC_TYPE || name.endsWith('.doc')) return 'doc'
+  if (type === PPT_TYPE || name.endsWith('.ppt')) return 'ppt'
+  return null
+}
+
+export type DocumentRefusal =
+  | { code: 'attachment-old-office-not-read'; name: string }
+  | { code: 'attachment-document-unreadable'; name: string }
+  | { code: 'attachment-document-empty'; name: string }
+  | { code: 'attachment-document-too-long'; name: string; maxChars: number }
+  | { code: 'attachment-scan-needs-images'; name: string }
+  | { code: 'attachment-scan-too-many-pages'; name: string; pages: number; max: number }
+
+/** What a document becomes: one text file, and the scanned pages of a PDF as images. */
+export interface DocumentFiles {
+  text: { name: string; text: string }
+  images: { name: string; page: number; blob: Blob }[]
+}
+
+/** The file name the text travels under - "계약서.pdf" → "계약서.pdf.txt", so the source stays readable. */
+export const documentTextName = (fileName: string) => `${fileName}.txt`
+
+/** The file name a scanned page travels under - "계약서.pdf" page 3 → "계약서.pdf - p3.jpg". */
+export const scannedPageName = (fileName: string, page: number) => `${fileName} - p${page}.jpg`
+
+/* ── OOXML, read without a DOM: a small pull reader over the tags the text lives in ─────────────────────────── */
+
+export interface XmlToken {
+  kind: 'open' | 'close' | 'empty' | 'text'
+  name?: string
+  attrs?: string
+  text?: string
+}
+
+const ENTITIES: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" }
+
+export function xmlDecode(text: string): string {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, code: string) => {
+    if (code[0] === '#') {
+      const n = code[1] === 'x' || code[1] === 'X' ? parseInt(code.slice(2), 16) : parseInt(code.slice(1), 10)
+      return Number.isFinite(n) ? String.fromCodePoint(n) : whole
+    }
+    return ENTITIES[code.toLowerCase()] ?? whole
+  })
+}
+
+/** Tags and text in document order. Comments, declarations and processing instructions are skipped. */
+export function* xmlTokens(xml: string): Generator<XmlToken> {
+  const pattern = /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!\[CDATA\[([\s\S]*?)\]\]>|<!(?:[^>]*)>|<(\/?)([\w:.-]+)([^>]*?)(\/?)>|([^<]+)/g
+  for (const match of xml.matchAll(pattern)) {
+    const [, cdata, slash, name, attrs, selfClose, text] = match
+    if (cdata !== undefined) yield { kind: 'text', text: cdata }
+    else if (name) yield { kind: slash ? 'close' : selfClose ? 'empty' : 'open', name, attrs }
+    else if (text !== undefined) yield { kind: 'text', text: xmlDecode(text) }
+  }
+}
+
+const attrOf = (attrs: string | undefined, name: string) => new RegExp(`\\b${name}="([^"]*)"`).exec(attrs ?? '')?.[1]
+
+/**
+ * A Word body as text: paragraphs in order, a heading led by "#" for its level, a table as one line per row with its
+ * cells between " | ". Text inside a table cell is joined with spaces, so a row stays one line.
+ */
+export function docxText(xml: string): string {
+  const lines: string[] = []
+  let paragraph = ''
+  let heading = 0
+  let inText = false
+  let tableDepth = 0
+  let row: string[] | null = null
+  let cell: string[] | null = null
+
+  for (const token of xmlTokens(xml)) {
+    const name = token.name
+    if (token.kind === 'text') {
+      if (inText) paragraph += token.text
+      continue
+    }
+    if (name === 'w:t') inText = token.kind === 'open'
+    else if (name === 'w:tab' && token.kind !== 'close') paragraph += '\t'
+    else if ((name === 'w:br' || name === 'w:cr') && token.kind !== 'close') paragraph += '\n'
+    else if (name === 'w:pStyle') {
+      const level = /^heading\s*(\d)$/i.exec(attrOf(token.attrs, 'w:val') ?? '')?.[1] ?? (/^title$/i.test(attrOf(token.attrs, 'w:val') ?? '') ? '1' : '')
+      heading = level ? Number(level) : 0
+    } else if (name === 'w:p' && token.kind === 'open') {
+      paragraph = ''
+      heading = 0
+    } else if (name === 'w:p' && token.kind !== 'open') {
+      const text = paragraph.replace(/[  ]+$/g, '')
+      if (cell) cell.push(text.trim())
+      else if (text.trim()) lines.push(heading ? `${'#'.repeat(heading)} ${text.trim()}` : text)
+      paragraph = ''
+    } else if (name === 'w:tbl') {
+      tableDepth += token.kind === 'open' ? 1 : token.kind === 'close' ? -1 : 0
+    } else if (name === 'w:tr' && tableDepth === 1) {
+      if (token.kind === 'open') row = []
+      else if (row) {
+        if (row.some(one => one)) lines.push(`| ${row.join(' | ')} |`)
+        row = null
+      }
+    } else if (name === 'w:tc' && tableDepth === 1) {
+      if (token.kind === 'open') cell = []
+      else if (cell) {
+        row?.push(cell.filter(Boolean).join(' '))
+        cell = null
+      }
+    }
+  }
+  return lines.join('\n')
+}
+
+/* What a slide or its notes repeat on every page - its number, date, footer, header - is not its content. */
+const REPEATED_PLACEHOLDERS = ['sldNum', 'dt', 'ftr', 'hdr']
+
+/** The text of one slide or notes part: each paragraph on its own line, the repeated placeholders left out. */
+export function drawingText(xml: string): string[] {
+  const lines: string[] = []
+  let paragraph = ''
+  let inText = false
+  let repeated = false
+  for (const token of xmlTokens(xml)) {
+    if (token.kind === 'text') {
+      if (inText) paragraph += token.text
+      continue
+    }
+    if (token.name === 'p:sp' && token.kind === 'open') repeated = false
+    else if (token.name === 'p:ph' && token.kind !== 'close') repeated = REPEATED_PLACEHOLDERS.includes(attrOf(token.attrs, 'type') ?? '')
+    else if (token.name === 'a:t') inText = token.kind === 'open'
+    else if (token.name === 'a:br' && token.kind !== 'close') paragraph += '\n'
+    else if (token.name === 'a:p' && token.kind !== 'open') {
+      if (paragraph.trim() && !repeated) lines.push(paragraph.trim())
+      paragraph = ''
+    }
+  }
+  return lines
+}
+
+/** The slides in the order the presentation shows them - its slide list read through its relationships. */
+export function slideOrder(presentationXml: string, relsXml: string): string[] {
+  const targets = new Map<string, string>()
+  for (const token of xmlTokens(relsXml)) {
+    if (token.name !== 'Relationship') continue
+    const id = attrOf(token.attrs, 'Id')
+    const target = attrOf(token.attrs, 'Target')
+    if (id && target) targets.set(id, target.replace(/^\/?ppt\//, '').replace(/^\.\//, ''))
+  }
+  const order: string[] = []
+  for (const token of xmlTokens(presentationXml)) {
+    if (token.name !== 'p:sldId') continue
+    const target = targets.get(attrOf(token.attrs, 'r:id') ?? '')
+    if (target) order.push(`ppt/${target}`)
+  }
+  return order
+}
+
+/** The notes part a slide points at, if it has one. */
+export function notesTarget(slidePath: string, slideRelsXml: string): string | null {
+  for (const token of xmlTokens(slideRelsXml)) {
+    if (token.name !== 'Relationship' || !/notesSlide$/.test(attrOf(token.attrs, 'Type') ?? '')) continue
+    const target = attrOf(token.attrs, 'Target')
+    if (!target) continue
+    const base = slidePath.split('/').slice(0, -1)
+    for (const part of target.split('/')) {
+      if (part === '..') base.pop()
+      else if (part !== '.') base.push(part)
+    }
+    return base.join('/')
+  }
+  return null
+}
+
+/** One slide as text: its paragraphs, then its speaker notes. */
+export function slideText(number: number, slide: string[], notes: string[]): string {
+  return [`--- slide ${number} ---`, ...slide, ...(notes.length ? ['notes:', ...notes] : [])].join('\n')
+}
+
+/** One PDF page's text items as lines - pdf.js marks the end of a line on the item that ends it. */
+export function pdfPageText(items: { str?: string; hasEOL?: boolean }[]): string {
+  let text = ''
+  for (const item of items) {
+    text += item.str ?? ''
+    if (item.hasEOL) text += '\n'
+  }
+  return text
+    .split('\n')
+    .map(line => line.replace(/[ \t]+/g, ' ').trim())
+    .filter(Boolean)
+    .join('\n')
+}
+
+/** A page with fewer letters than this is a scan - its text is a page number or a stray mark, not its content. */
+export const SCANNED_PAGE_LETTERS = 16
+
+export const isScannedPage = (text: string) => text.replace(/\s/g, '').length < SCANNED_PAGE_LETTERS
+
+/** The header line of a document's text - what it was and how it is marked. */
+export function documentHeader(fileName: string, kind: 'pdf' | 'docx' | 'pptx', count?: number): string {
+  const many = (word: string) => `${count} ${word}${count === 1 ? '' : 's'}`
+  if (kind === 'pdf') return `# ${fileName} · PDF · ${many('page')} · each page begins with "--- page N ---", N its own page number`
+  if (kind === 'pptx') return `# ${fileName} · PowerPoint · ${many('slide')} · each slide begins with "--- slide N ---", its notes after "notes:"`
+  return `# ${fileName} · Word · read in order, headings led by "#", table rows between "|"`
+}
+
+/** A finished text checked against the limit and for emptiness - the same three answers for every kind. */
+function settle(fileName: string, text: string, body: string, maxChars: number, images: DocumentFiles['images'] = []): { files: DocumentFiles } | { refusal: DocumentRefusal } {
+  if (!body.trim() && !images.length) return { refusal: { code: 'attachment-document-empty', name: fileName } }
+  if (text.length > maxChars) return { refusal: { code: 'attachment-document-too-long', name: fileName, maxChars } }
+  return { files: { text: { name: documentTextName(fileName), text }, images } }
+}
+
+/** What reads a zip - JSZip, passed in so the screen loads it only when a document is attached. */
+export interface ZipReader {
+  loadAsync(data: ArrayBuffer | Uint8Array): Promise<{ file(path: string): { async(type: 'string'): Promise<string> } | null }>
+}
+
+export async function readDocx(data: ArrayBuffer | Uint8Array, fileName: string, maxChars: number, zip: ZipReader) {
+  let body: string
+  try {
+    const archive = await zip.loadAsync(data)
+    const part = archive.file('word/document.xml')
+    if (!part) return { refusal: { code: 'attachment-document-unreadable', name: fileName } as DocumentRefusal }
+    body = docxText(await part.async('string'))
+  } catch {
+    return { refusal: { code: 'attachment-document-unreadable', name: fileName } as DocumentRefusal }
+  }
+  return settle(fileName, `${documentHeader(fileName, 'docx')}\n${body}\n`, body, maxChars)
+}
+
+export async function readPptx(data: ArrayBuffer | Uint8Array, fileName: string, maxChars: number, zip: ZipReader) {
+  const slides: string[] = []
+  try {
+    const archive = await zip.loadAsync(data)
+    const read = async (path: string) => (await archive.file(path)?.async('string')) ?? null
+    const presentation = await read('ppt/presentation.xml')
+    const rels = await read('ppt/_rels/presentation.xml.rels')
+    if (!presentation || !rels) return { refusal: { code: 'attachment-document-unreadable', name: fileName } as DocumentRefusal }
+    const order = slideOrder(presentation, rels)
+    for (const [index, path] of order.entries()) {
+      const slide = await read(path)
+      if (slide === null) continue
+      const slideRels = await read(path.replace(/slides\/(slide\d+\.xml)$/, 'slides/_rels/$1.rels'))
+      const notesPath = slideRels ? notesTarget(path, slideRels) : null
+      const notes = notesPath ? await read(notesPath) : null
+      slides.push(slideText(index + 1, drawingText(slide), notes ? drawingText(notes) : []))
+    }
+  } catch {
+    return { refusal: { code: 'attachment-document-unreadable', name: fileName } as DocumentRefusal }
+  }
+  const body = slides.join('\n')
+  const said = slides.some(slide => slide.split('\n').length > 1)
+  return settle(fileName, `${documentHeader(fileName, 'pptx', slides.length)}\n${body}\n`, said ? body : '', maxChars)
+}
+
+/** What reads a PDF - pdf.js's document, narrowed to what is used, so a test can hand in pages. */
+export interface PdfSource {
+  numPages: number
+  getPage(number: number): Promise<{ getTextContent(): Promise<{ items: any[] }> }>
+}
+
+/**
+ * Every page of a PDF as text, its scanned pages drawn as images by `drawPage` (the screen's canvas). A scan cannot be
+ * read unless the mode takes images, and no more scanned pages are drawn than the message may carry - both refused by
+ * name, never dropped.
+ */
+export async function readPdf(
+  open: () => Promise<PdfSource>,
+  fileName: string,
+  maxChars: number,
+  scans: { allowed: boolean; max: number },
+  drawPage: (number: number) => Promise<Blob>
+): Promise<{ files: DocumentFiles } | { refusal: DocumentRefusal }> {
+  const pages: string[] = []
+  const scanned: number[] = []
+  let count = 0
+  try {
+    const pdf = await open()
+    count = pdf.numPages
+    for (let number = 1; number <= count; number++) {
+      const page = await pdf.getPage(number)
+      const text = pdfPageText((await page.getTextContent()).items)
+      if (isScannedPage(text)) {
+        scanned.push(number)
+        pages.push(`--- page ${number} ---\n(no text on this page - a scan, sent as the image "${scannedPageName(fileName, number)}")`)
+      } else pages.push(`--- page ${number} ---\n${text}`)
+    }
+  } catch {
+    return { refusal: { code: 'attachment-document-unreadable', name: fileName } }
+  }
+  if (scanned.length && !scans.allowed) return { refusal: { code: 'attachment-scan-needs-images', name: fileName } }
+  if (scanned.length > scans.max) return { refusal: { code: 'attachment-scan-too-many-pages', name: fileName, pages: scanned.length, max: scans.max } }
+  const images: DocumentFiles['images'] = []
+  try {
+    for (const page of scanned) images.push({ name: scannedPageName(fileName, page), page, blob: await drawPage(page) })
+  } catch {
+    return { refusal: { code: 'attachment-document-unreadable', name: fileName } }
+  }
+  const body = pages.join('\n')
+  const read = scanned.length < count ? body : ''
+  return settle(fileName, `${documentHeader(fileName, 'pdf', count)}\n${body}\n`, read, maxChars, images)
+}

package/client/utils/entry-hash.ts

@@ -1,5 +1,5 @@
 /*
- * One 입력안's fingerprint - what the AI 작업판 showed and what the card enters are the same proposal
+ * One 입력안's fingerprint - what the AI 작업 패널 showed and what the card enters are the same proposal
  * (operato-application/design/ai/workspace.md §6-1). The screen's copy and the server's are one rule;
  * `test/entry-hash-agree.test.ts` runs both over one table.
  *

package/client/utils/entry-proposal.ts

@@ -106,7 +106,7 @@ export function entryProposalHandler(
 ) {
   return async (proposal: any, context: ProposalContext): Promise<ProposalOutcome> => {
     if (!context.sessionId || !proposal?.key) return { verdict: 'unavailable', errorCode: 'no-conversation' }
-    /* Reviewed in the 작업판: entered only as it was shown there (design/ai/workspace.md §6-1) - here, and again at the server. */
+    /* Reviewed in the 작업 패널: entered only as it was shown there (design/ai/workspace.md §6-1) - here, and again at the server. */
     const reviewed = reviewedOf(proposal.key)
     if (!reviewStillHolds(proposal, reviewed)) return { verdict: 'refused', errorCode: 'review-stale', note: t('ai-assistant.entry.review-stale', { defaultValue: 'this proposal changed after it was reviewed in the workspace - review it again before entering.' }) } as any
     const answer = { ...(await apply(context.sessionId, proposal.key, reviewed)), op: proposal.op }

package/client/utils/entry-workspace.ts

@@ -1,5 +1,5 @@
 /*
- * Reviewing a 입력안 in the AI 작업판 (operato-application/design/ai/workspace.md §6-1). Pure but for the
+ * Reviewing a 입력안 in the AI 작업 패널 (operato-application/design/ai/workspace.md §6-1). Pure but for the
  * session store - tested without a browser.
  *
  * The page is read-only: every column and every row, sorted as stored, issues marked. The one place that enters

package/client/utils/pdf-pages.ts

@@ -0,0 +1,38 @@
+/*
+ * pdf.js on the screen - loaded only when a PDF is attached, its worker started once (document-text.ts reads the
+ * pages; this opens the file and draws a scanned page into an image).
+ */
+let loading: Promise<any> | undefined
+
+/** pdf.js with its worker - the worker parses the file off the page's thread. */
+export function loadPdfjs(): Promise<any> {
+  loading ??= (async () => {
+    const pdfjs: any = await import('pdfjs-dist')
+    if (!pdfjs.GlobalWorkerOptions.workerPort) {
+      pdfjs.GlobalWorkerOptions.workerPort = new Worker(new URL('pdfjs-dist/build/pdf.worker.min.mjs', import.meta.url), { type: 'module' })
+    }
+    return pdfjs
+  })()
+  return loading
+}
+
+/** The longest side of a drawn page, in pixels - enough for a model to read print, small enough to send. */
+export const PAGE_IMAGE_SIDE = 1600
+
+/** One page drawn into a JPEG. */
+export async function drawPdfPage(pdf: any, number: number): Promise<Blob> {
+  const page = await pdf.getPage(number)
+  const base = page.getViewport({ scale: 1 })
+  const viewport = page.getViewport({ scale: Math.min(2, PAGE_IMAGE_SIDE / Math.max(base.width, base.height)) })
+  const canvas = document.createElement('canvas')
+  canvas.width = Math.ceil(viewport.width)
+  canvas.height = Math.ceil(viewport.height)
+  const context = canvas.getContext('2d')!
+  /* A page draws on transparent pixels; a JPEG would turn them black. */
+  context.fillStyle = '#ffffff'
+  context.fillRect(0, 0, canvas.width, canvas.height)
+  await page.render({ canvas, canvasContext: context, viewport }).promise
+  return await new Promise<Blob>((resolve, reject) =>
+    canvas.toBlob(blob => (blob ? resolve(blob) : reject(new Error('the page could not be drawn'))), 'image/jpeg', 0.85)
+  )
+}

package/client/utils/workspace.ts

@@ -1,5 +1,5 @@
 /*
- * The AI 작업판 on the screen - which versions a workspace has, and the table's sort and CSV
+ * The AI 작업 패널 on the screen - which versions a workspace has, and the table's sort and CSV
  * (operato-application/design/ai/workspace.md). Pure - tested without a browser.
  */
 

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

@@ -245,6 +245,8 @@ export declare class OxAssistantChat extends LitElement {
     private onAttachFiles;
     /** Each .xlsx replaced by one CSV file per sheet; any other file passes as it is. */
     private readSpreadsheets;
+    /** Each document replaced by its text, and a PDF's scanned pages by their images; any other file passes as it is. */
+    private readDocuments;
     private readFileAsBase64;
     private removeAttachment;
     /** A pasted table goes back into the box as the words it was copied as - the conversion was not the person's choice. */
@@ -580,7 +582,7 @@ export declare class OxAssistantChat extends LitElement {
     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. */
+    /** The AI 작업 패널 card - what it holds, which version, and the way to open it. The person opens it; the model does not. */
     private renderWorkspaceCard;
     /**
      * 눌린 카드가 말하는 것 — **호스트가 한 일**이고, 아직 모르면 모른다고 말한다.