@things-factory/ai-assistant 10.1.88 → 10.1.91

package/client/components/workspace-view.ts

@@ -0,0 +1,428 @@
+/*
+ * 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
+ * 3:1 against the surface, so every chart carries its legend (two series or more) and a table view.
+ */
+import '@material/web/icon/icon.js'
+
+import { LitElement, css, html, nothing, svg, type TemplateResult } from 'lit'
+import { customElement, property, state } from 'lit/decorators.js'
+import { unsafeHTML } from 'lit/directives/unsafe-html.js'
+
+import { i18next } from '@operato/i18n'
+
+import { renderMarkdown } from './markdown.js'
+import { sortRows, tableCsv, type WorkspaceBlockView, type WorkspaceView } from '../utils/workspace.js'
+
+const LIGHT = ['#2a78d6', '#eb6834', '#1baf7a', '#eda100', '#e87ba4', '#008300', '#4a3aa7', '#e34948']
+const DARK = ['#3987e5', '#d95926', '#199e70', '#c98500', '#d55181', '#008300', '#9085e9', '#e66767']
+
+const t = (key: string, defaultValue: string, options: Record<string, unknown> = {}) =>
+  String(i18next.t(`ai-assistant.workspace.${key}`, { defaultValue, ...options }))
+
+const shown = (value: unknown) =>
+  value === null || value === undefined ? '' : typeof value === 'number' ? value.toLocaleString(i18next.language || undefined) : String(value)
+
+/** Four round steps from zero to above the largest value. */
+function ticksFor(max: number): number[] {
+  if (!(max > 0)) return [0, 1]
+  const raw = max / 4
+  const power = 10 ** Math.floor(Math.log10(raw))
+  const step = [1, 2, 2.5, 5, 10].map(one => one * power).find(one => one >= raw) ?? raw
+  return Array.from({ length: Math.ceil(max / step) + 1 }, (_, i) => Math.round(i * step * 1e6) / 1e6)
+}
+
+@customElement('ox-assistant-workspace-view')
+export class AssistantWorkspaceView extends LitElement {
+  static styles = css`
+    :host {
+      display: block;
+      color: var(--md-sys-color-on-surface);
+      font-size: 14px;
+      line-height: 1.5;
+    }
+
+    section {
+      margin: 0 0 20px;
+    }
+
+    h1,
+    h2,
+    h3 {
+      margin: 24px 0 8px;
+      line-height: 1.3;
+    }
+
+    h1 {
+      font-size: 22px;
+    }
+
+    h2 {
+      font-size: 18px;
+    }
+
+    h3 {
+      font-size: 15px;
+    }
+
+    .metrics {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(170px, 1fr));
+      gap: 10px;
+    }
+
+    .metric {
+      padding: 12px 14px;
+      border: 1px solid var(--md-sys-color-outline-variant);
+      border-radius: 10px;
+      background: var(--md-sys-color-surface-container-lowest);
+    }
+
+    .metric .label {
+      color: var(--md-sys-color-on-surface-variant);
+      font-size: 12px;
+    }
+
+    .metric .value {
+      font-size: 22px;
+      font-weight: 650;
+      font-variant-numeric: tabular-nums;
+    }
+
+    .metric .note {
+      color: var(--md-sys-color-on-surface-variant);
+      font-size: 12px;
+    }
+
+    .bar {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      margin-bottom: 6px;
+      color: var(--md-sys-color-on-surface-variant);
+      font-size: 12px;
+    }
+
+    .bar .caption {
+      flex: 1;
+    }
+
+    .bar button {
+      display: inline-flex;
+      align-items: center;
+      gap: 4px;
+      padding: 3px 8px;
+      border: 1px solid var(--md-sys-color-outline-variant);
+      border-radius: 6px;
+      background: transparent;
+      color: inherit;
+      font: inherit;
+      cursor: pointer;
+    }
+
+    .bar md-icon {
+      --md-icon-size: 16px;
+    }
+
+    .scroll {
+      max-height: 560px;
+      overflow: auto;
+      border: 1px solid var(--md-sys-color-outline-variant);
+      border-radius: 8px;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 13px;
+    }
+
+    th,
+    td {
+      padding: 6px 10px;
+      border-bottom: 1px solid var(--md-sys-color-outline-variant);
+      text-align: start;
+      white-space: nowrap;
+    }
+
+    th {
+      position: sticky;
+      top: 0;
+      background: var(--md-sys-color-surface-container);
+      font-weight: 600;
+    }
+
+    th button {
+      border: 0;
+      padding: 0;
+      background: none;
+      color: inherit;
+      font: inherit;
+      cursor: pointer;
+    }
+
+    td.num,
+    th.num {
+      text-align: end;
+      font-variant-numeric: tabular-nums;
+    }
+
+    .chart svg {
+      width: 100%;
+      height: auto;
+      display: block;
+    }
+
+    .chart .grid {
+      stroke: var(--md-sys-color-outline-variant);
+      stroke-width: 1;
+    }
+
+    .chart .tick {
+      fill: var(--md-sys-color-on-surface-variant);
+      font-size: 11px;
+    }
+
+    .legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 4px 14px;
+      margin-top: 6px;
+      font-size: 12px;
+    }
+
+    .legend .swatch {
+      display: inline-block;
+      width: 10px;
+      height: 10px;
+      margin-inline-end: 5px;
+      border-radius: 3px;
+      vertical-align: -1px;
+    }
+
+    .steps {
+      list-style: none;
+      margin: 0;
+      padding: 0;
+    }
+
+    .steps li {
+      display: flex;
+      gap: 8px;
+      padding: 4px 0;
+    }
+
+    .steps md-icon {
+      --md-icon-size: 18px;
+    }
+
+    .steps .done md-icon {
+      color: var(--md-sys-color-primary);
+    }
+
+    .steps .failed md-icon {
+      color: var(--md-sys-color-error);
+    }
+
+    .steps .note {
+      display: block;
+      color: var(--md-sys-color-on-surface-variant);
+      font-size: 12px;
+    }
+
+    .unreadable,
+    .cut {
+      color: var(--md-sys-color-on-surface-variant);
+      font-size: 12px;
+      font-style: italic;
+    }
+
+    .markdown :first-child {
+      margin-top: 0;
+    }
+  `
+
+  @property({ attribute: false }) workspace?: WorkspaceView
+
+  @state() private sorts: Record<number, { column: string; direction: 'asc' | 'desc' }> = {}
+  @state() private asTable = new Set<number>()
+  @state() private dark = false
+
+  private themeWatch?: MutationObserver
+
+  connectedCallback() {
+    super.connectedCallback()
+    this.dark = document.body.classList.contains('dark')
+    this.themeWatch = new MutationObserver(() => (this.dark = document.body.classList.contains('dark')))
+    this.themeWatch.observe(document.body, { attributes: true, attributeFilter: ['class'] })
+  }
+
+  disconnectedCallback() {
+    this.themeWatch?.disconnect()
+    super.disconnectedCallback()
+  }
+
+  render() {
+    const blocks = this.workspace?.blocks ?? []
+    return html`${blocks.map((block, i) => this.block(block, i))}`
+  }
+
+  private block(block: WorkspaceBlockView, i: number): TemplateResult {
+    switch (block.kind) {
+      case 'heading':
+        return block.level === 1 ? html`<h1>${block.text}</h1>` : block.level === 3 ? html`<h3>${block.text}</h3>` : html`<h2>${block.text}</h2>`
+      case 'text':
+        return html`<section class="markdown">${unsafeHTML(renderMarkdown(block.markdown))}</section>`
+      case 'metrics':
+        return html`<section class="metrics">
+          ${(block.items ?? []).map(
+            (one: any) => html`<div class="metric">
+              <div class="label">${one.label}</div>
+              <div class="value">${shown(one.value)}${one.unit ? html` <small>${one.unit}</small>` : nothing}</div>
+              ${one.note ? html`<div class="note">${one.note}</div>` : nothing}
+            </div>`
+          )}
+        </section>`
+      case 'table':
+        return this.table(block, i)
+      case 'chart':
+        return this.chart(block, i)
+      case 'steps':
+        return html`<section>
+          <ol class="steps">
+            ${(block.items ?? []).map(
+              (one: any) => html`<li class=${one.state}>
+                <md-icon>${{ done: 'check_circle', doing: 'progress_activity', failed: 'error', todo: 'radio_button_unchecked' }[one.state as string] ?? 'radio_button_unchecked'}</md-icon>
+                <span>${one.label}${one.note ? html`<span class="note">${one.note}</span>` : nothing}</span>
+              </li>`
+            )}
+          </ol>
+        </section>`
+      default:
+        return html`<section class="unreadable">${t('unreadable', 'a block that cannot be drawn ({reason})', { reason: block.reason ?? block.kind })}</section>`
+    }
+  }
+
+  private table(block: WorkspaceBlockView, i: number): TemplateResult {
+    const columns: { name: string; label?: string; type?: string }[] = block.columns ?? []
+    const sort = this.sorts[i]
+    const rows = sort ? sortRows(block.rows ?? [], sort.column, sort.direction, i18next.language) : block.rows ?? []
+    const toggle = (column: string) =>
+      (this.sorts = { ...this.sorts, [i]: { column, direction: sort?.column === column && sort.direction === 'asc' ? 'desc' : 'asc' } })
+    return html`<section>
+      <div class="bar">
+        <span class="caption">${block.caption ?? ''} · ${t('rows', '{count} rows', { count: rows.length })}</span>
+        <button @click=${() => this.download(block.caption || this.workspace?.title || 'table', columns, rows)}>
+          <md-icon>download</md-icon>${t('csv', 'CSV')}
+        </button>
+      </div>
+      ${this.tableOf(columns, rows, sort, toggle)}
+      ${block.cut ? html`<div class="cut">${t('cut', '{count} more rows were left out over the limit.', { count: block.cut })}</div>` : nothing}
+    </section>`
+  }
+
+  private tableOf(columns: { name: string; label?: string; type?: string }[], rows: Record<string, any>[], sort?: { column: string; direction: string }, toggle?: (column: string) => void) {
+    return html`<div class="scroll">
+      <table>
+        <thead>
+          <tr>
+            ${columns.map(
+              column => html`<th class=${column.type === 'number' ? 'num' : ''} aria-sort=${sort?.column === column.name ? (sort.direction === 'asc' ? 'ascending' : 'descending') : 'none'}>
+                ${toggle
+                  ? html`<button @click=${() => toggle(column.name)}>${column.label || column.name}${sort?.column === column.name ? (sort.direction === 'asc' ? ' ▲' : ' ▼') : ''}</button>`
+                  : column.label || column.name}
+              </th>`
+            )}
+          </tr>
+        </thead>
+        <tbody>
+          ${rows.map(row => html`<tr>${columns.map(column => html`<td class=${column.type === 'number' || typeof row[column.name] === 'number' ? 'num' : ''}>${shown(row[column.name])}</td>`)}</tr>`)}
+        </tbody>
+      </table>
+    </div>`
+  }
+
+  private chart(block: WorkspaceBlockView, i: number): TemplateResult {
+    const colours = this.dark ? DARK : LIGHT
+    const x: string[] = block.x ?? []
+    const series: { name: string; other?: boolean; values: (number | null)[] }[] = block.series ?? []
+    const name = (one: { name: string; other?: boolean }) => (one.other ? t('other', 'other') : one.name)
+    const showingTable = this.asTable.has(i)
+    const flip = () => {
+      const next = new Set(this.asTable)
+      next.has(i) ? next.delete(i) : next.add(i)
+      this.asTable = next
+    }
+
+    const bar = html`<div class="bar">
+      <span class="caption">${block.caption ?? ''}${block.unit ? ` (${block.unit})` : ''}</span>
+      <button @click=${flip}><md-icon>${showingTable ? 'bar_chart' : 'table_rows'}</md-icon>${showingTable ? t('as-chart', 'chart') : t('as-table', 'table')}</button>
+    </div>`
+
+    if (showingTable) {
+      const columns = [{ name: '_x', label: '' }, ...series.map((one, s) => ({ name: `s${s}`, label: name(one), type: 'number' }))]
+      const rows = x.map((label, j) => Object.fromEntries([['_x', label], ...series.map((one, s) => [`s${s}`, one.values[j]])]))
+      return html`<section class="chart">${bar}${this.tableOf(columns, rows)}</section>`
+    }
+
+    const W = 640
+    const H = 240
+    const left = 56
+    const bottom = 28
+    const plotW = W - left - 8
+    const plotH = H - bottom - 10
+    const values = series.flatMap(one => one.values).filter((v): v is number => typeof v === 'number')
+    const min = Math.min(0, ...values)
+    const ticks = ticksFor(Math.max(...values, 0) - min).map(tick => tick + min)
+    const top = ticks[ticks.length - 1] || 1
+    const y = (v: number) => 10 + plotH - ((v - min) / (top - min || 1)) * plotH
+    const band = plotW / Math.max(1, x.length)
+    const everyNth = Math.max(1, Math.ceil(x.length / 12))
+
+    const marks =
+      block.chart === 'line'
+        ? series.map((one, s) => {
+            const points = one.values.map((v, j) => (typeof v === 'number' ? [left + band * (j + 0.5), y(v)] : null))
+            const path = points.reduce((d, p, j) => (p ? `${d}${d && points[j - 1] ? 'L' : 'M'}${p[0]},${p[1]}` : d), '')
+            return svg`<path d=${path} fill="none" stroke=${colours[s % 8]} stroke-width="2" stroke-linejoin="round" stroke-linecap="round"></path>
+              ${points.map((p, j) =>
+                p ? svg`<circle cx=${p[0]} cy=${p[1]} r="4" fill=${colours[s % 8]} stroke="var(--md-sys-color-surface)" stroke-width="2"><title>${name(one)} · ${x[j]}: ${shown(one.values[j])}</title></circle>` : nothing
+              )}`
+          })
+        : series.map((one, s) => {
+            const inner = band * 0.7
+            const width = Math.max(2, inner / series.length - 2)
+            return one.values.map((v, j) => {
+              if (typeof v !== 'number') return nothing
+              const x0 = left + band * j + (band - inner) / 2 + s * (width + 2)
+              const y0 = Math.min(y(v), y(0))
+              const h = Math.max(1, Math.abs(y(v) - y(0)))
+              return svg`<rect x=${x0} y=${y0} width=${width} height=${h} rx="3" fill=${colours[s % 8]}><title>${name(one)} · ${x[j]}: ${shown(v)}</title></rect>`
+            })
+          })
+
+    return html`<section class="chart" role="img" aria-label=${block.caption || series.map(name).join(', ')}>
+      ${bar}
+      <svg viewBox="0 0 ${W} ${H}">
+        ${ticks.map(tick => svg`<line class="grid" x1=${left} x2=${W - 8} y1=${y(tick)} y2=${y(tick)}></line><text class="tick" x=${left - 6} y=${y(tick) + 4} text-anchor="end">${shown(tick)}</text>`)}
+        ${marks}
+        ${x.map((label, j) => (j % everyNth ? nothing : svg`<text class="tick" x=${left + band * (j + 0.5)} y=${H - 8} text-anchor="middle">${label}</text>`))}
+      </svg>
+      ${series.length > 1
+        ? html`<div class="legend">${series.map((one, s) => html`<span><span class="swatch" style="background:${colours[s % 8]}"></span>${name(one)}</span>`)}</div>`
+        : nothing}
+    </section>`
+  }
+
+  private download(title: string, columns: { name: string; label?: string }[], rows: Record<string, any>[]) {
+    const blob = new Blob([tableCsv(columns, rows)], { type: 'text/csv;charset=utf-8' })
+    const url = URL.createObjectURL(blob)
+    const link = document.createElement('a')
+    link.href = url
+    link.download = `${title.replace(/[\\/:*?"<>|]+/g, '-').slice(0, 80)}.csv`
+    link.click()
+    setTimeout(() => URL.revokeObjectURL(url), 1000)
+  }
+}

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

@@ -0,0 +1,237 @@
+/*
+ * The AI 작업판 page (operato-application/design/ai/workspace.md).
+ *
+ * `assistant-workspace?session=<id>&name=<name>[&version=<n>]`. 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 gql from 'graphql-tag'
+import { css, html, nothing } from 'lit'
+import { customElement, state } from 'lit/decorators.js'
+
+import { client } from '@operato/graphql'
+import { i18next, localize } from '@operato/i18n'
+import { navigate, PageView } from '@operato/shell'
+import { ScrollbarStyles } from '@operato/styles'
+
+import { startSessionActivityFeed, subscribeSessionActivity } from '../utils/assistant-activity.js'
+import { workspaceAddress, workspaceVersions, type WorkspaceVersion } from '../utils/workspace.js'
+
+const MESSAGES = gql`
+  query ($sessionId: String!, $limit: Int, $offset: Int) {
+    chatMessages(sessionId: $sessionId, limit: $limit, offset: $offset) {
+      id
+      createdAt
+      proposalsJson
+    }
+  }
+`
+
+const PAGE = 200
+const MOST = 5000
+
+const t = (key: string, defaultValue: string, options: Record<string, unknown> = {}) =>
+  String(i18next.t(`ai-assistant.workspace.${key}`, { defaultValue, ...options }))
+
+@customElement('assistant-workspace-page')
+export class AssistantWorkspacePage extends localize(i18next)(PageView) {
+  static styles = [
+    ScrollbarStyles,
+    css`
+      :host {
+        display: block;
+        overflow: auto;
+        padding: 20px 24px 40px;
+        box-sizing: border-box;
+        background: var(--md-sys-color-surface);
+      }
+
+      .page {
+        max-width: 1100px;
+        margin: 0 auto;
+      }
+
+      header {
+        display: flex;
+        align-items: flex-start;
+        gap: 12px;
+        margin-bottom: 16px;
+      }
+
+      header .what {
+        flex: 1;
+        min-width: 0;
+      }
+
+      header h1 {
+        margin: 0;
+        font-size: 24px;
+        line-height: 1.3;
+      }
+
+      header .summary {
+        margin-top: 4px;
+        color: var(--md-sys-color-on-surface-variant);
+      }
+
+      header select {
+        padding: 4px 8px;
+        border: 1px solid var(--md-sys-color-outline-variant);
+        border-radius: 6px;
+        background: var(--md-sys-color-surface-container-lowest);
+        color: inherit;
+        font: inherit;
+      }
+
+      .notice {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        margin-bottom: 14px;
+        padding: 8px 12px;
+        border-radius: 8px;
+        background: var(--md-sys-color-secondary-container);
+        color: var(--md-sys-color-on-secondary-container);
+      }
+
+      .notice button {
+        padding: 3px 10px;
+        border: 1px solid currentColor;
+        border-radius: 6px;
+        background: transparent;
+        color: inherit;
+        font: inherit;
+        cursor: pointer;
+      }
+
+      .empty {
+        padding: 40px 0;
+        color: var(--md-sys-color-on-surface-variant);
+        text-align: center;
+      }
+    `
+  ]
+
+  @state() private sessionId = ''
+  @state() private name = ''
+  @state() private wanted = 0
+  @state() private versions: WorkspaceVersion[] = []
+  @state() private loading = false
+  @state() private failure = ''
+  /** A version that arrived after the page was drawn - announced, not shown until asked. */
+  @state() private newer = 0
+
+  private unsubscribe?: () => void
+
+  get context() {
+    const shown = this.shown
+    return { title: shown?.workspace.title || t('title', 'AI workspace') }
+  }
+
+  private get shown(): WorkspaceVersion | undefined {
+    if (!this.versions.length) return undefined
+    return this.versions.find(one => one.version === this.wanted) ?? this.versions[this.versions.length - 1]
+  }
+
+  connectedCallback() {
+    super.connectedCallback()
+    startSessionActivityFeed()
+    this.unsubscribe = subscribeSessionActivity(activity => {
+      if (activity.sessionId === this.sessionId && activity.kind === 'message') void this.load(true)
+    })
+  }
+
+  disconnectedCallback() {
+    this.unsubscribe?.()
+    super.disconnectedCallback()
+  }
+
+  async pageUpdated(_changes: any, lifecycle: any) {
+    const params = lifecycle?.params ?? {}
+    const sessionId = String(params.session || '')
+    const name = String(params.name || '')
+    const wanted = Number(params.version) || 0
+    const changed = sessionId !== this.sessionId || name !== this.name
+    this.sessionId = sessionId
+    this.name = name
+    this.wanted = wanted
+    if (changed) {
+      this.newer = 0
+      await this.load(false)
+    }
+  }
+
+  private async load(arriving: boolean) {
+    if (!this.sessionId || !this.name) return
+    const before = this.versions.length
+    if (!arriving) this.loading = true
+    this.failure = ''
+    try {
+      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
+      }
+      const versions = workspaceVersions(messages, this.name)
+      this.versions = versions
+      if (arriving && versions.length > before && before > 0) this.newer = versions[versions.length - 1].version
+    } catch (error: any) {
+      this.failure = error?.message || String(error)
+    } finally {
+      this.loading = false
+    }
+  }
+
+  private go(version?: number) {
+    this.newer = 0
+    navigate(workspaceAddress(this.sessionId, this.name, version))
+  }
+
+  render() {
+    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>`
+    /*
+     * Nothing to show says only what is true: this reader sees no such workspace. Whether it never existed, is in
+     * a private conversation or sits behind a door is not said - saying which would itself tell.
+     */
+    if (!shown) return html`<div class="empty">${t('not-found', 'there is no workspace here that you can see.')}</div>`
+
+    const latest = this.versions[this.versions.length - 1].version
+    return html`<div class="page">
+      ${this.newer && this.newer !== shown.version
+        ? html`<div class="notice" role="status">
+            <md-icon>update</md-icon>
+            <span>${t('newer', 'a newer version ({version}) is ready.', { version: this.newer })}</span>
+            <button @click=${() => this.go(this.newer)}>${t('show-newer', 'show it')}</button>
+          </div>`
+        : nothing}
+      <header>
+        <div class="what">
+          <h1>${shown.workspace.title}</h1>
+          ${shown.workspace.summary ? html`<div class="summary">${shown.workspace.summary}</div>` : nothing}
+        </div>
+        ${this.versions.length > 1
+          ? html`<select aria-label=${t('versions', 'versions')} @change=${(e: Event) => this.go(Number((e.target as HTMLSelectElement).value))}>
+              ${this.versions
+                .slice()
+                .reverse()
+                .map(
+                  one => html`<option value=${one.version} ?selected=${one.version === shown.version}>
+                    ${t('version', 'version {version} of {of}', { version: one.version, of: latest })}${one.createdAt ? ` · ${new Date(one.createdAt).toLocaleString(i18next.language || undefined)}` : ''}
+                  </option>`
+                )}
+            </select>`
+          : nothing}
+      </header>
+      <ox-assistant-workspace-view .workspace=${shown.workspace}></ox-assistant-workspace-view>
+    </div>`
+  }
+}

package/client/route.ts

@@ -0,0 +1,9 @@
+/* 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). */
+    case 'assistant-workspace':
+      import('./pages/assistant-workspace-page.js')
+      return page
+  }
+}

package/client/utils/assistant-proposals.ts

@@ -37,9 +37,19 @@ export function proposalHandlerOf(tool: string | undefined): ProposalHandler | u
   return tool ? handlers.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.
+ */
+let entryHandler: ProposalHandler | undefined
+
+export function setEntryProposalHandler(handler: ProposalHandler): void {
+  entryHandler = handler
+}
+
 /** Runs the proposal - never throws; a failure is a `refused` outcome with its message as the code. */
 export async function runProposal(proposal: any, context: ProposalContext): Promise<ProposalOutcome> {
-  const handler = proposalHandlerOf(proposal?.tool)
+  const handler = proposal?.kind === 'entry' && entryHandler ? entryHandler : proposalHandlerOf(proposal?.tool)
   if (!handler) return { verdict: 'unavailable', errorCode: 'unknown-proposal-kind' }
   try {
     const outcome = await handler(proposal, context)