@things-factory/ai-assistant 10.1.107 → 10.1.109

package/client/components/assistant-chat.ts

@@ -32,7 +32,10 @@ import {
   injectMentionUserIds,
   stripMentionRefids
 } from './markdown.js'
-import { acceptOf, chatAttachmentUrl, refuseAttachments } from '../utils/attachment-policy.js'
+import { acceptOf, chatAttachmentUrl, refuseAttachments, textCharsOf } from '../utils/attachment-policy.js'
+import { pastedTableFile } from '../utils/pasted-table.js'
+import { readSpreadsheet, spreadsheetKindOf, type SpreadsheetRefusal } from '../utils/spreadsheet-text.js'
+import { entryReviewAddress, offersWorkspaceReview } from '../utils/entry-workspace.js'
 import { buildAssistantChatInput, buildChatMutationInput } from './chat-input-builder.js'
 import { receiveRemoteMessage, reconcileSentLine, remoteMessageToLine } from './chat-echo-dedup.js'
 import './mention-popup.js'
@@ -639,7 +642,16 @@ export class OxAssistantChat extends LitElement {
 
   private async onAttachFiles(files: FileList | File[] | null | undefined) {
     if (!files || files.length === 0) return
-    const list = Array.from(files)
+    let list = Array.from(files)
+    if (this.usesAttachmentPolicy && this.modeView?.attachments?.kinds?.includes('spreadsheet')) {
+      /* A spreadsheet travels as the text of its sheets (§9-5) - read here, refused by name when it cannot be. */
+      const read = await this.readSpreadsheets(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). */
       const refusal = refuseAttachments(this.modeView?.attachments, [...this.attachments, ...list].map(f => ({ name: f.name, type: f.type, size: f.size })))
@@ -673,6 +685,28 @@ export class OxAssistantChat extends LitElement {
     this.attachments = [...this.attachments, ...newAttachments]
   }
 
+  /** Each .xlsx replaced by one CSV file per sheet; any other file passes as it is. */
+  private async readSpreadsheets(list: File[]): Promise<{ files: File[] } | { refusal: SpreadsheetRefusal }> {
+    const out: File[] = []
+    let Workbook: any
+    for (const file of list) {
+      const kind = spreadsheetKindOf(file)
+      if (!kind) {
+        out.push(file)
+        continue
+      }
+      if (kind === 'xls') return { refusal: { code: 'attachment-xls-not-read', name: file.name } }
+      if (!Workbook) {
+        const mod: any = await import('exceljs')
+        Workbook = (mod.default ?? mod).Workbook
+      }
+      const read = await readSpreadsheet(await file.arrayBuffer(), file.name, textCharsOf(this.modeView?.attachments), Workbook)
+      if ('refusal' in read) return read
+      for (const sheet of read.files) out.push(new File([sheet.text], sheet.name, { type: 'text/csv' }))
+    }
+    return { files: out }
+  }
+
   private readFileAsBase64(file: File): Promise<string> {
     return new Promise((resolve, reject) => {
       const reader = new FileReader()
@@ -694,6 +728,27 @@ export class OxAssistantChat extends LitElement {
     const items = e.clipboardData?.items
     if (!items || items.length === 0) return
 
+    /*
+      Rows copied from a spreadsheet or a web page travel as a file, so the entry card can check each row against
+      its line. A spreadsheet also puts a picture of the cells on the clipboard - with the table taken, it is left.
+    */
+    if (this.usesAttachmentPolicy) {
+      const pasted = pastedTableFile(
+        { html: e.clipboardData?.getData('text/html'), text: e.clipboardData?.getData('text/plain') },
+        this.modeView?.attachments,
+        rows => String(i18next.t('ai-assistant.text.pasted-table-name', { rows, defaultValue: 'pasted table ({rows} rows)' }))
+      )
+      if (pasted) {
+        e.preventDefault()
+        if ('refusal' in pasted) {
+          this.errorMessage = String(i18next.t(`ai-assistant.text.${pasted.refusal.code}`, { ...pasted.refusal, defaultValue: pasted.refusal.code }))
+          return
+        }
+        this.onAttachFiles([new File([pasted.text], pasted.name, { type: 'text/csv' })])
+        return
+      }
+    }
+
     const files: File[] = []
     for (let i = 0; i < items.length; i++) {
       const item = items[i]
@@ -1964,6 +2019,42 @@ export class OxAssistantChat extends LitElement {
       color: inherit;
     }
 
+    /* The entry card's way to the large review - a quiet action under its table, never a second run button. */
+    .workspace-review {
+      display: flex;
+      align-items: center;
+      gap: 5px;
+      margin: 6px 0 0 auto;
+      padding: 5px 11px 5px 9px;
+      border: 1px solid transparent;
+      border-radius: 999px;
+      background: transparent;
+      color: var(--md-sys-color-primary, #0f766e);
+      font-family: inherit;
+      font-size: 12px;
+      font-weight: 600;
+      letter-spacing: 0.01em;
+      cursor: pointer;
+      transition:
+        background-color 0.14s ease-in-out,
+        border-color 0.14s ease-in-out;
+    }
+    .workspace-review md-icon {
+      --md-icon-size: 15px;
+      color: inherit;
+    }
+    .workspace-review:hover {
+      background: color-mix(in srgb, var(--md-sys-color-primary, #0f766e) 8%, transparent);
+      border-color: color-mix(in srgb, var(--md-sys-color-primary, #0f766e) 24%, transparent);
+    }
+    .workspace-review:active {
+      background: color-mix(in srgb, var(--md-sys-color-primary, #0f766e) 14%, transparent);
+    }
+    .workspace-review:focus-visible {
+      outline: 2px solid var(--md-sys-color-primary, #0f766e);
+      outline-offset: 1px;
+    }
+
     /* ── 접지 경고 — 근거에 없는 대상을 지목한 답 ───── */
     .grounding-warning {
       display: flex;
@@ -3250,6 +3341,11 @@ export class OxAssistantChat extends LitElement {
   }
 
   private onKeyDown(e: KeyboardEvent) {
+    /*
+      The Enter that ends a Korean (or Japanese, Chinese) syllable belongs to the input method - sending on it
+      sends the line without its last syllable, which then lands in the emptied box.
+    */
+    if (e.isComposing || e.keyCode === 229) return
     // Mention popup 활성 시 — 화살표/Enter/Tab/Esc 가로채서 popup 네비게이션
     if (this.mentionOpen) {
       if (e.key === 'ArrowDown') {
@@ -4021,6 +4117,16 @@ export class OxAssistantChat extends LitElement {
               ` : nothing}
             </div>
             ${entry ? html`<ox-assistant-entry-review .proposal=${p}></ox-assistant-entry-review>` : nothing}
+            ${entry && this.sessionId && offersWorkspaceReview(p)
+              ? html`<button
+                  class="workspace-review"
+                  @click=${() =>
+                    this.dispatchEvent(new CustomEvent('assistant-open-page', { detail: { href: entryReviewAddress(this.sessionId!, key) }, bubbles: true, composed: true }))}
+                >
+                  <md-icon>open_in_full</md-icon>
+                  <span>${i18next.t('ai-assistant.entry.review-in-workspace', { defaultValue: 'review in the workspace' })}</span>
+                </button>`
+              : nothing}
             ${rawChoices.length ? html`
               <div class="proposal-choices" role="group" aria-label=${i18next.t('ai-assistant.text.proposal-choices', { defaultValue: 'follow-up choices' })}>
                 ${rawChoices.map((c: any) => html`

package/client/components/assistant-dock.ts

@@ -42,14 +42,14 @@ const t = (key: string, defaultValue: string, options: Record<string, unknown> =
 /* Pressing a data entry card asks the server to enter the rows it stored - the screen sends none (design/ai/data-entry.md §4). */
 setEntryProposalHandler(
   entryProposalHandler(
-    async (sessionId, proposalKey) => {
+    async (sessionId, proposalKey, reviewedHash) => {
       const result = await client.mutate({
         mutation: gql`
-          mutation ($id: String!, $key: String!) {
-            applyEntryProposal(sessionId: $id, proposalKey: $key)
+          mutation ($id: String!, $key: String!, $reviewed: String) {
+            applyEntryProposal(sessionId: $id, proposalKey: $key, reviewedHash: $reviewed)
           }
         `,
-        variables: { id: sessionId, key: proposalKey }
+        variables: { id: sessionId, key: proposalKey, reviewed: reviewedHash ?? null }
       })
       if (result.errors?.length) throw new Error(result.errors[0].message)
       return result.data?.applyEntryProposal as EntryApplyAnswer

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')[]; maxBytes?: number; maxFiles?: number }
+  attachments?: { kinds: ('image' | 'text' | 'spreadsheet')[]; 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,6 +178,24 @@ 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). */
+    :host([wide]) {
+      font-size: 13px;
+    }
+
+    :host([wide]) .scroll {
+      max-height: calc(100vh - 260px);
+    }
+
+    :host([wide]) th,
+    :host([wide]) td {
+      padding: 6px 10px;
+    }
+
+    :host([wide]) .source {
+      max-width: 320px;
+    }
+
     .more,
     .check-failed {
       margin-top: 4px;
@@ -187,6 +205,8 @@ export class AssistantEntryReview extends LitElement {
   ]
 
   @property({ attribute: false }) proposal: any
+  /** 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. */
   private renderTotals(totals: EntryTotalView[], columns: { name: string; labelKey?: string }[]) {
@@ -236,7 +256,7 @@ export class AssistantEntryReview extends LitElement {
             </tr>
           </thead>
           <tbody>
-            ${rows.slice(0, SHOWN).map(row => {
+            ${rows.slice(0, this.wide ? rows.length : SHOWN).map(row => {
               const blocked = (row.issues ?? []).some((issue: EntryIssueView) => issue.blocking)
               const whole = entryCellIssues(row)
               return html`<tr class=${blocked ? 'blocked' : ''}>
@@ -286,7 +306,7 @@ export class AssistantEntryReview extends LitElement {
             </tr>
           </thead>
           <tbody>
-            ${rows.slice(0, SHOWN).map(row => {
+            ${rows.slice(0, this.wide ? rows.length : SHOWN).map(row => {
               const blocked = (row.issues ?? []).some(issue => issue.blocking)
               const whole = entryCellIssues(row)
               return html`
@@ -319,7 +339,7 @@ export class AssistantEntryReview extends LitElement {
         </table>
       </div>
       ${this.renderTotals(p.totals ?? [], columns)}
-      ${rows.length > SHOWN ? html`<div class="more">${t('more-rows', '{count} more rows are not shown - they are entered too.', { count: rows.length - SHOWN })}</div>` : nothing}
+      ${!this.wide && rows.length > SHOWN ? html`<div class="more">${t('more-rows', '{count} more rows are not shown - they are entered too.', { count: rows.length - SHOWN })}</div>` : nothing}
       ${p.checkFailed ? html`<div class="check-failed">${t('check-failed', 'the application could not check these rows; they are checked again when entered.')}</div>` : nothing}
     `
   }

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

@@ -1,13 +1,15 @@
 /*
  * The AI 작업판 page (operato-application/design/ai/workspace.md).
  *
- * `assistant-workspace?session=<id>&name=<name>[&version=<n>]`. It reads the conversation through its own
+ * `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
  * door (`chatMessages`), so a private conversation shows nothing to someone outside it and a version behind a
  * door the reader cannot pass is not among the versions (ADR-0073). A new version arriving while the page is
  * open is announced, never swapped in under the reader.
  */
 import '@material/web/icon/icon.js'
 import '../components/workspace-view.js'
+import '../components/entry-review.js'
 
 import gql from 'graphql-tag'
 import { css, html, nothing } from 'lit'
@@ -20,6 +22,8 @@ import { ScrollbarStyles } from '@operato/styles'
 
 import { startSessionActivityFeed, subscribeSessionActivity } from '../utils/assistant-activity.js'
 import { workspaceAddress, workspaceVersions, type WorkspaceVersion } from '../utils/workspace.js'
+import { entryForReview, rememberReviewed } from '../utils/entry-workspace.js'
+import { entryTitle } from '../utils/entry-proposal.js'
 
 const MESSAGES = gql`
   query ($sessionId: String!, $limit: Int, $offset: Int) {
@@ -55,6 +59,11 @@ export class AssistantWorkspacePage extends localize(i18next)(PageView) {
         margin: 0 auto;
       }
 
+      /* A 입력안 is as wide as its columns - the reason it left the dock. */
+      .page.entry {
+        max-width: none;
+      }
+
       header {
         display: flex;
         align-items: flex-start;
@@ -124,10 +133,14 @@ export class AssistantWorkspacePage extends localize(i18next)(PageView) {
   @state() private failure = ''
   /** A version that arrived after the page was drawn - announced, not shown until asked. */
   @state() private newer = 0
+  /** Reviewing a 입력안: its key, what was found, and whether a newer card replaced it. */
+  @state() private entryKey = ''
+  @state() private entry?: { proposal?: any; createdAt?: string; superseded: boolean }
 
   private unsubscribe?: () => void
 
   get context() {
+    if (this.entryKey) return { title: this.entry?.proposal ? entryTitle(this.entry.proposal, (key, options) => String(i18next.t(key, options))) : t('title', 'AI workspace') }
     const shown = this.shown
     return { title: shown?.workspace.title || t('title', 'AI workspace') }
   }
@@ -141,7 +154,7 @@ export class AssistantWorkspacePage extends localize(i18next)(PageView) {
     super.connectedCallback()
     startSessionActivityFeed()
     this.unsubscribe = subscribeSessionActivity(activity => {
-      if (activity.sessionId === this.sessionId && activity.kind === 'message') void this.load(true)
+      if (activity.sessionId === this.sessionId && activity.kind === 'message') void (this.entryKey ? this.loadEntry() : this.load(true))
     })
   }
 
@@ -155,6 +168,16 @@ export class AssistantWorkspacePage extends localize(i18next)(PageView) {
     const sessionId = String(params.session || '')
     const name = String(params.name || '')
     const wanted = Number(params.version) || 0
+    const entryKey = String(params.entry || '')
+    if (entryKey) {
+      const changedEntry = sessionId !== this.sessionId || entryKey !== this.entryKey
+      this.sessionId = sessionId
+      this.entryKey = entryKey
+      this.name = ''
+      if (changedEntry) await this.loadEntry()
+      return
+    }
+    this.entryKey = ''
     const changed = sessionId !== this.sessionId || name !== this.name
     this.sessionId = sessionId
     this.name = name
@@ -189,12 +212,69 @@ export class AssistantWorkspacePage extends localize(i18next)(PageView) {
     }
   }
 
+  private async readMessages(): Promise<any[]> {
+    const messages: any[] = []
+    for (let offset = 0; offset < MOST; offset += PAGE) {
+      const result = await client.query({ query: MESSAGES, variables: { sessionId: this.sessionId, limit: PAGE, offset }, fetchPolicy: 'no-cache' })
+      if (result.errors?.length) throw new Error(result.errors[0].message)
+      const page = result.data?.chatMessages ?? []
+      messages.push(...page)
+      if (page.length < PAGE) break
+    }
+    return messages
+  }
+
+  /** The 입력안 under review - remembered as shown, so the card enters only this one (§6-1). */
+  private async loadEntry() {
+    if (!this.sessionId || !this.entryKey) return
+    this.loading = !this.entry
+    this.failure = ''
+    try {
+      const found = entryForReview(await this.readMessages(), this.entryKey)
+      this.entry = found
+      if (found.proposal && !found.superseded) rememberReviewed(found.proposal)
+    } catch (error: any) {
+      this.failure = error?.message || String(error)
+    } finally {
+      this.loading = false
+    }
+  }
+
+  private renderEntry() {
+    const found = this.entry
+    if (this.loading && !found) return html`<div class="empty">${t('loading', 'loading the workspace…')}</div>`
+    if (this.failure) return html`<div class="empty">${t('unreadable-page', 'could not read this workspace: {reason}', { reason: this.failure })}</div>`
+    if (!found?.proposal) return html`<div class="empty">${t('entry-not-found', 'there is no proposal here that you can see.')}</div>`
+    const p = found.proposal
+    return html`<div class="page entry">
+      ${found.superseded
+        ? html`<div class="notice" role="status">
+            <md-icon>update</md-icon>
+            <span>${t('entry-superseded', 'a newer card replaced this one in the conversation - review that one.')}</span>
+          </div>`
+        : html`<div class="notice" role="note">
+            <md-icon>touch_app</md-icon>
+            <span>${t('entry-press-in-dock', 'this is a review. Enter the rows with the button on the card in the AI dock.')}</span>
+          </div>`}
+      <header>
+        <div class="what">
+          <h1>${entryTitle(p, (key, options) => String(i18next.t(key, options)))}</h1>
+          ${p.reason || found.createdAt
+            ? html`<div class="summary">${[p.reason, found.createdAt ? new Date(found.createdAt).toLocaleString(i18next.language || undefined) : ''].filter(Boolean).join(' · ')}</div>`
+            : nothing}
+        </div>
+      </header>
+      <ox-assistant-entry-review wide .proposal=${p}></ox-assistant-entry-review>
+    </div>`
+  }
+
   private go(version?: number) {
     this.newer = 0
     navigate(workspaceAddress(this.sessionId, this.name, version))
   }
 
   render() {
+    if (this.entryKey) return this.renderEntry()
     const shown = this.shown
     if (this.loading && !shown) return html`<div class="empty">${t('loading', 'loading the workspace…')}</div>`
     if (this.failure) return html`<div class="empty">${t('unreadable-page', 'could not read this workspace: {reason}', { reason: this.failure })}</div>`

package/client/utils/attachment-policy.ts

@@ -6,16 +6,24 @@
  * the authority. `test/attachment-policy-agree.test.ts` runs both copies over one table so they cannot drift.
  */
 
-export type AttachmentKind = 'image' | 'text'
+/*
+ * '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.
+ */
+export type AttachmentKind = 'image' | 'text' | 'spreadsheet'
 
 export interface AttachmentPolicy {
   kinds: AttachmentKind[]
   maxBytes?: number
   maxFiles?: number
+  /** Per text file, the characters the model reads - a sheet read into text longer than this is refused, not cut. */
+  maxChars?: number
 }
 
 export const DEFAULT_MAX_BYTES = 5 * 1024 * 1024
 export const DEFAULT_MAX_FILES = 5
+/** How much of a text file reaches the model - the server's TEXT_CHARS_FOR_MODEL. */
+export const TEXT_CHARS_FOR_MODEL = 20_000
 
 const TEXT_TYPES = ['text/plain', 'text/csv', 'text/markdown', 'application/json']
 const TEXT_EXTENSIONS = ['.txt', '.csv', '.md', '.json']
@@ -35,6 +43,16 @@ export type AttachmentRefusal =
   | { code: 'attachment-too-large'; name: string; maxBytes: number }
   | { code: 'too-many-attachments'; maxFiles: number }
 
+/** A kind the policy takes - text also when it takes spreadsheets, which arrive as the text of their sheets. */
+function takes(policy: AttachmentPolicy, kind: AttachmentKind): boolean {
+  return policy.kinds.includes(kind) || (kind === 'text' && policy.kinds.includes('spreadsheet'))
+}
+
+/** The characters of a text file the model reads under this policy. */
+export function textCharsOf(policy: AttachmentPolicy | null | undefined): number {
+  return policy?.maxChars ?? TEXT_CHARS_FOR_MODEL
+}
+
 export function refuseAttachments(
   policy: AttachmentPolicy | null | undefined,
   files: { name?: string; type?: string; size?: number }[]
@@ -48,7 +66,7 @@ export function refuseAttachments(
   const maxBytes = policy.maxBytes ?? DEFAULT_MAX_BYTES
   for (const file of files) {
     const kind = attachmentKindOf(file)
-    if (!kind || !policy.kinds.includes(kind)) {
+    if (!kind || !takes(policy, kind)) {
       return { code: 'attachment-kind-not-accepted', name: file.name || '', kinds: policy.kinds }
     }
     if ((file.size ?? 0) > maxBytes) return { code: 'attachment-too-large', name: file.name || '', maxBytes }
@@ -60,7 +78,8 @@ export function refuseAttachments(
 export function acceptOf(policy: AttachmentPolicy | null | undefined): string {
   const accept: string[] = []
   if (policy?.kinds?.includes('image')) accept.push('image/*')
-  if (policy?.kinds?.includes('text')) accept.push(...TEXT_EXTENSIONS, ...TEXT_TYPES)
+  if (policy?.kinds?.includes('text') || policy?.kinds?.includes('spreadsheet')) accept.push(...TEXT_EXTENSIONS, ...TEXT_TYPES)
+  if (policy?.kinds?.includes('spreadsheet')) accept.push('.xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
   return accept.join(',')
 }
 

package/client/utils/entry-hash.ts

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ *
+ * It covers what is entered: the key, the target, create or change, and each row's index, record and values.
+ */
+
+const canonical = (value: unknown): string => {
+  if (value === null || value === undefined) return 'null'
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`
+  if (typeof value === 'object')
+    return `{${Object.keys(value as object)
+      .filter(name => (value as any)[name] !== undefined)
+      .sort()
+      .map(name => `${JSON.stringify(name)}:${canonical((value as any)[name])}`)
+      .join(',')}}`
+  return JSON.stringify(value)
+}
+
+/** FNV-1a over the canonical text - a fingerprint to compare, not a secret. */
+export function entryProposalHash(proposal: any): string {
+  const text = canonical({
+    key: proposal?.key,
+    target: proposal?.target,
+    op: proposal?.op ?? 'create',
+    rows: (proposal?.rows ?? []).map((row: any) => ({ index: row?.index, id: row?.id, values: row?.values ?? {} }))
+  })
+  let hash = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i)
+    hash = Math.imul(hash, 0x01000193) >>> 0
+  }
+  return `${hash.toString(16).padStart(8, '0')}-${text.length.toString(16)}`
+}

package/client/utils/entry-proposal.ts

@@ -6,6 +6,7 @@
  * screen sends no rows of its own.
  */
 import type { ProposalContext, ProposalOutcome } from './assistant-proposals.js'
+import { reviewedHashOf, reviewStillHolds } from './entry-workspace.js'
 
 export interface EntryIssueView {
   field?: string
@@ -93,12 +94,18 @@ export function entryOutcomeNote(answer: EntryApplyAnswer, t: (key: string, opti
 
 /** The handler every entry card runs - built with the mutation so the rules are tested without a server. */
 export function entryProposalHandler(
-  apply: (sessionId: string, proposalKey: string) => Promise<EntryApplyAnswer>,
-  t: (key: string, options?: any) => string
+  apply: (sessionId: string, proposalKey: string, reviewedHash?: string) => Promise<EntryApplyAnswer>,
+  t: (key: string, options?: any) => string,
+  reviewedOf: (key: string) => string | undefined = reviewedHashOf
 ) {
   return async (proposal: any, context: ProposalContext): Promise<ProposalOutcome> => {
     if (!context.sessionId || !proposal?.key) return { verdict: 'unavailable', errorCode: 'no-conversation' }
-    const answer = { ...(await apply(context.sessionId, proposal.key)), op: proposal.op }
+    /* 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 }
+    if (answer.errorCode === 'review-stale')
+      return { verdict: 'refused', errorCode: 'review-stale', applied: 0, missed: 0, note: t('ai-assistant.entry.review-stale', { defaultValue: 'this proposal changed after it was reviewed in the workspace - review it again before entering.' }) }
     return {
       verdict: answer.verdict,
       ...(answer.errorCode ? { errorCode: answer.errorCode } : {}),

package/client/utils/entry-workspace.ts

@@ -0,0 +1,70 @@
+/*
+ * 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
+ * is the dock's card. What the page showed is remembered by its fingerprint, and the card sends it - a proposal
+ * that changed in between is refused, and the person reviews it again.
+ */
+import { entryProposalHash } from './entry-hash.js'
+
+/** A card wide or long enough not to be read in the dock. */
+export const WORKSPACE_ROWS = 20
+export const WORKSPACE_COLUMNS = 6
+
+export function offersWorkspaceReview(proposal: any): boolean {
+  return (proposal?.rows?.length ?? 0) > WORKSPACE_ROWS || (proposal?.columns?.length ?? 0) > WORKSPACE_COLUMNS
+}
+
+export function entryReviewAddress(sessionId: string, proposalKey: string): string {
+  return `assistant-workspace?${new URLSearchParams({ session: sessionId, entry: proposalKey }).toString()}`
+}
+
+/** The proposal of that key among the conversation's messages, and whether a newer card of the same record replaced it. */
+export function entryForReview(messages: { id: string; createdAt?: string; proposalsJson?: any[] | null }[], key: string): { proposal?: any; createdAt?: string; superseded: boolean } {
+  let at = -1
+  let proposal: any
+  let createdAt: string | undefined
+  messages.forEach((message, i) => {
+    for (const one of message.proposalsJson ?? []) if (one?.kind === 'entry' && one?.key === key) (at = i), (proposal = one), (createdAt = message.createdAt)
+  })
+  if (!proposal) return { superseded: false }
+  const superseded = messages
+    .slice(at + 1)
+    .some(message => (message.proposalsJson ?? []).some(one => one?.kind === 'entry' && one?.target === proposal.target && (one?.op ?? 'create') === (proposal.op ?? 'create')))
+  return { proposal, createdAt, superseded }
+}
+
+const STORE = 'ai-assistant.entry-reviewed:'
+
+/** Remembers what the page showed for this key. A browser that keeps nothing keeps nothing - the card then sends no fingerprint. */
+export function rememberReviewed(proposal: any, store: Pick<Storage, 'setItem'> | undefined = safeSession()): string {
+  const hash = entryProposalHash(proposal)
+  try {
+    store?.setItem(STORE + proposal.key, hash)
+  } catch {
+    /* private window or blocked storage */
+  }
+  return hash
+}
+
+export function reviewedHashOf(key: string, store: Pick<Storage, 'getItem'> | undefined = safeSession()): string | undefined {
+  try {
+    return store?.getItem(STORE + key) ?? undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** Whether the card may be pressed: not reviewed, or reviewed as it stands now. */
+export function reviewStillHolds(proposal: any, reviewed: string | undefined): boolean {
+  return !reviewed || reviewed === entryProposalHash(proposal)
+}
+
+function safeSession(): Storage | undefined {
+  try {
+    return typeof sessionStorage === 'undefined' ? undefined : sessionStorage
+  } catch {
+    return undefined
+  }
+}