@things-factory/ai-assistant 10.1.227 → 10.1.229

package/client/components/assistant-chat.ts

@@ -1,6 +1,6 @@
 import { replyDestination, quotedReply } from './reply-message.js'
 import { rosterName } from './roster-identity'
-import { notify } from '@operato/layout'
+import { entity360KindRegistered, notify } from '@operato/layout'
 import './assistant-invite.js'
 import { TypingRoom } from '../utils/assistant-typing.js'
 import { isInviteProposal, personLine, type InvitePerson } from '../utils/invite-proposal.js'
@@ -78,11 +78,11 @@ import {
  */
 import { chatDefaults } from './chat-defaults.js'
 import { isDifferentConversation, resolveConversation, type AssistantMode, type AssistantModeView } from './assistant-mode.js'
-import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState, type ParsedProposalOutcome } from './proposal-outcome-line.js'
+import { entryWentIn, parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState, type ParsedProposalOutcome } from './proposal-outcome-line.js'
 import './entry-review.js'
-import { entryGroupOf, entryReadyCount, entryTitle, isChangeProposal, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js'
+import { entryGroupOf, entryReadyCount, entryRecordsOf, entryScreenAddress, 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 { isAppAddress, isOpenPageProposal, openPageNote } from '../utils/open-page.js'
 import { proposalViewOf } from '../utils/assistant-proposals.js'
 
 interface ChatLine {
@@ -4559,6 +4559,7 @@ export class OxAssistantChat extends LitElement {
     /* The card's state is the conversation's rows - read once for every card of this line. */
     const outcomes = this.proposalOutcomes
     const requested = this.proposalRequests
+    const records = this.entryRecords
     /* A data entry card replaced by a newer one for the same record cannot be entered (design/ai/data-entry.md §5). */
     const latestEntry = items.some(isEntryProposal) ? latestEntryKeys(this.lines.map(one => one.proposals ?? [])) : undefined
     return html`
@@ -4626,6 +4627,12 @@ export class OxAssistantChat extends LitElement {
                               : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
+              ${/* What went in is seen on its screen - the card's next step once applied, beside its outcome. */ ''}
+              ${entry && entryWentIn(card) && isAppAddress(p.screen)
+                ? html`<button class="run see" @click=${() => this.openEntryScreen(p, key, records)}>
+                    ${i18next.t('ai-assistant.entry.see-on-screen', { defaultValue: 'see on the screen' })}
+                  </button>`
+                : nothing}
               ${/*
                   Drawn only where the host has said it staged this candidate, in the host's own
                   words. Not knowing is not a claim: with no word from the host, nothing is drawn.
@@ -4953,6 +4960,22 @@ export class OxAssistantChat extends LitElement {
     )
   }
 
+  /** The records each entry card entered - from the conversation's notes, like the outcomes, so a refresh keeps them. */
+  private get entryRecords(): Map<string, string[]> {
+    const records = new Map<string, string[]>()
+    for (const line of this.lines) {
+      if (line.role !== 'system') continue
+      const entered = entryRecordsOf(line.content ?? '')
+      if (entered) records.set(entered.key, entered.ids)
+    }
+    return records
+  }
+
+  private openEntryScreen(p: any, key: string, records: Map<string, string[]>) {
+    const href = entryScreenAddress(p, records.get(key), entity360KindRegistered)
+    this.dispatchEvent(new CustomEvent('assistant-open-page', { detail: { href }, bubbles: true, composed: true }))
+  }
+
   /** Keys whose run was requested - from the conversation's rows, like the outcomes. */
   private get proposalRequests(): Set<string> {
     const requested = new Set<string>()

package/client/components/assistant-dock.ts

@@ -11,7 +11,7 @@ import { keyed } from 'lit/directives/keyed.js'
 
 import { client } from '@operato/graphql'
 import { i18next, localize } from '@operato/i18n'
-import { closeOverlay, notify } from '@operato/layout'
+import { closeOverlay, notify, refreshEntity360 } from '@operato/layout'
 import { OxPrompt } from '@operato/popup'
 import { AppController, navigate, store } from '@operato/shell'
 import { ScrollbarStyles } from '@operato/styles'
@@ -31,6 +31,7 @@ import {
   type AssistantSurface
 } from '../utils/assistant-surface.js'
 import { runProposal, setEntryProposalHandler, type ProposalContext, type ProposalOutcome } from '../utils/assistant-proposals.js'
+import { refreshAppliedScreens, type AppliedScreensDeps } from '../utils/applied-screens.js'
 /* The invite card's handler - ai-assistant's own tool, registered by its own module (design/ai/shared-dock.md §4). */
 import '../utils/invite-proposal-register.js'
 import { entryProposalHandler, type EntryApplyAnswer } from '../utils/entry-proposal.js'
@@ -62,6 +63,15 @@ setEntryProposalHandler(
   )
 )
 
+/* The page on screen and the shown 360 - what an applied card's records may be shown on. */
+const APPLIED_SCREENS: AppliedScreensDeps = {
+  page: () => {
+    const route = (store.getState() as any)?.route ?? {}
+    return { name: route.page, element: route.activePage }
+  },
+  refresh360: refreshEntity360
+}
+
 const MODE_QUERY = gql`
   query ($subject: String!) {
     assistantModeFor(subject: $subject) {
@@ -785,9 +795,15 @@ export class AssistantDock extends localize(i18next)(LitElement) {
     if (outcome.verdict === 'unavailable' && outcome.errorCode === 'unknown-proposal-kind') {
       notify({ level: 'error', message: t('proposal-not-runnable', 'this proposal cannot be run on this screen.') })
     }
-    await this.report(sessionId, proposalKey, outcome)
+    const { records, ...reported } = outcome
+    await this.report(sessionId, proposalKey, reported)
     /* What the handler did, in the person's words, stays in the conversation - what was created, why it did not run. */
     if (outcome.note && sessionId) await this.appendNote(sessionId, outcome.note)
+    /* The list or 360 behind the dock shows what went in, without the person refreshing it. */
+    if (outcome.verdict === 'accepted' && (outcome.applied ?? 1) > 0)
+      void refreshAppliedScreens(proposal, records, APPLIED_SCREENS).then(kept => {
+        if (kept) notify({ level: 'info', message: t('screen-kept-edits', 'the list was not read again - it has unsaved edits. save them, then refresh it to see what went in.') })
+      })
   }
 
   /**

package/client/components/proposal-outcome-line.ts

@@ -67,3 +67,8 @@ export function proposalCardState(
   if (seen.requested.has(key)) return { state: 'unconfirmed' }
   return { state: 'ready' }
 }
+
+/** Something went in - the card then offers the screen where it is seen. A refusal, or nothing entered, offers none. */
+export function entryWentIn(card: ProposalCardState): boolean {
+  return card.state === 'answered' && card.outcome.verdict === 'accepted' && (card.outcome.applied ?? 0) > 0
+}

package/client/utils/applied-screens.ts

@@ -0,0 +1,36 @@
+/*
+ * The screens that show what an applied card wrote read it again (2026-10-29). Applied from the dock, a card left the
+ * list and the 360 behind it as they were, and people took it for not applied.
+ *
+ * Only a screen that shows those records reads again - the shown 360 of the record or of a record the card is about,
+ * and the page that is the card's screen. Another page keeps its rows and its scroll. A page with unsaved edits is
+ * not asked about them by a refresh nobody pressed: it is left as it is, and its own refresh control reads it later.
+ */
+
+export interface AppliedScreensDeps {
+  /** The page on screen - its route name and the shell's page element (`PageView.refresh`, ADR-0174). */
+  page(): { name?: string; element?: { refresh?: (options?: { ask?: boolean }) => Promise<boolean> } }
+  /** The 360's refresh, asked whether it is about the shown subject. */
+  refresh360(about: (subject: { kind: string; id: string }) => boolean): boolean
+}
+
+/**
+ * Reads again what shows the records of an applied card. Never throws - a screen that cannot read keeps what it shows.
+ * `kept-edits` when the card's page was left unread for its unsaved edits - the person is told, or the list looks unapplied.
+ */
+export async function refreshAppliedScreens(proposal: any, ids: string[] | undefined, deps: AppliedScreensDeps): Promise<'kept-edits' | undefined> {
+  const kind = String(proposal?.target ?? '').split('.')[1] ?? ''
+  const axes: string[] = Array.isArray(proposal?.axes) ? proposal.axes : []
+  try {
+    deps.refresh360(subject => (subject.kind === kind && !!ids?.includes(subject.id)) || axes.includes(subject.kind))
+  } catch {
+    /* the 360 keeps what it shows; its refresh button reads it */
+  }
+  const page = deps.page()
+  if (!proposal?.screen || page.name !== proposal.screen || typeof page.element?.refresh !== 'function') return
+  try {
+    return (await page.element.refresh({ ask: false })) === false ? 'kept-edits' : undefined
+  } catch {
+    /* the page keeps what it shows; its refresh control reads it */
+  }
+}

package/client/utils/assistant-proposals.ts

@@ -14,6 +14,8 @@ export interface ProposalOutcome {
   missed?: number
   /** A line for the conversation, besides the outcome itself (e.g. what was created). */
   note?: string
+  /** The ids of the records it wrote - the screens that show them read again. Not reported to the conversation. */
+  records?: string[]
 }
 
 export interface ProposalContext {

package/client/utils/assistant-selection.ts

@@ -6,6 +6,7 @@
  * 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",…}`.
  */
+import { ENTRY_RECORDS_PREFIX } from './entry-proposal.js'
 
 /**
  * The grid's own row picker - a list that hands its rows to the assistant shows it beside `ox-assistant-selection-bar`
@@ -64,11 +65,11 @@ export function selectionNote(selection: AssistantSelection, t: SelectionTransla
   return `${named}\n${keys}`
 }
 
-/** A note as the conversation draws it - without the line only the model reads. */
+/** A note as the conversation draws it - without the lines only the model reads (a selection's keys, an entry's records). */
 export function noteForDisplay(content: string): string {
   return (content ?? '')
     .split('\n')
-    .filter(line => !line.startsWith(SELECTION_KEYS_PREFIX))
+    .filter(line => !line.startsWith(SELECTION_KEYS_PREFIX) && !line.startsWith(ENTRY_RECORDS_PREFIX))
     .join('\n')
     .trim()
 }

package/client/utils/entry-proposal.ts

@@ -5,6 +5,8 @@
  * again - the newer card replaces the older one. Pressing asks the server to enter the stored rows; the
  * screen sends no rows of its own.
  */
+import { encodeListQuery } from '@operato/utils/list-query.js'
+
 import type { ProposalContext, ProposalOutcome } from './assistant-proposals.js'
 import { reviewedHashOf, reviewStillHolds } from './entry-workspace.js'
 
@@ -49,6 +51,9 @@ export interface EntryApplyAnswer extends ProposalOutcome {
   refusal?: { message: string; extensions: Record<string, unknown>; path: string[] }
   /** Set by the handler from the card - which words the conversation line uses. */
   op?: string
+  /** Set by the handler from the card - which card and record kind the entered ids belong to. */
+  key?: string
+  target?: string
 }
 
 export function isEntryProposal(proposal: any): boolean {
@@ -90,7 +95,56 @@ export function entryOutcomeNote(answer: EntryApplyAnswer, t: (key: string, opti
       : t('ai-assistant.entry.entered-none', { defaultValue: 'no row was entered.' })
   const lines = refused.slice(0, 20).map(row => t('ai-assistant.entry.row-refused', { defaultValue: 'row {n}: {reason}', n: row.index + 1, reason: row.error || '' }))
   const more = refused.length > 20 ? [t('ai-assistant.entry.more-refused', { defaultValue: '{count} more rows were not entered.', count: refused.length - 20 })] : []
-  return [head, ...lines, ...more].join('\n')
+  const records = entryRecordsLine(answer)
+  return [head, ...appliedNames(answer, t), ...lines, ...more, ...(records ? [records] : [])].join('\n')
+}
+
+/**
+ * The line of an entry note that names the records a card entered - for the card, which opens them on their screen, and
+ * for the model. The conversation does not draw it. Not `[keys]`: that line is the person's selection, and a card's
+ * records must not replace what "these" means.
+ */
+export const ENTRY_RECORDS_PREFIX = '[records]'
+
+const enteredIds = (answer: EntryApplyAnswer): string[] => [...new Set((answer.rows ?? []).filter(row => row.ok && row.id).map(row => row.id as string))]
+
+function entryRecordsLine(answer: EntryApplyAnswer): string {
+  const ids = enteredIds(answer)
+  return ids.length && answer.key && answer.target ? `${ENTRY_RECORDS_PREFIX} ${answer.key} ${answer.target} ${ids.join(' ')}` : ''
+}
+
+/** The card key, record kind and ids of an entry note's records line - undefined for any other content. */
+export function entryRecordsOf(content: string): { key: string; target: string; ids: string[] } | undefined {
+  const line = (content ?? '').split('\n').find(one => one.startsWith(`${ENTRY_RECORDS_PREFIX} `))
+  const [key, target, ...ids] = line ? line.slice(ENTRY_RECORDS_PREFIX.length).trim().split(/\s+/) : []
+  return key && target && ids.length ? { key, target, ids } : undefined
+}
+
+/** At most this many ids narrow a list in its address - more open the list as it is. */
+export const ENTRY_SCREEN_IDS = 50
+
+/**
+ * Where the card's "see on the screen" goes. One record of a kind with a 360 opens that 360 beside its list; records
+ * of the list the screen shows narrow it to them, a condition the person sees and removes; otherwise the screen as it is.
+ */
+export function entryScreenAddress(proposal: any, ids: string[] | undefined, has360: (kind: string) => boolean): string {
+  const screen: string = proposal?.screen
+  const kind = String(proposal?.target ?? '').split('.')[1] ?? ''
+  if (ids?.length === 1 && kind && has360(kind)) return `${screen}?${new URLSearchParams({ f: `${kind}:${ids[0]}` })}`
+  if (ids?.length && ids.length <= ENTRY_SCREEN_IDS && proposal?.screenLists)
+    return `${screen}?${encodeListQuery({ filters: [{ name: 'id', operator: 'in', value: ids }] })}`
+  return screen
+}
+
+/*
+ * Which records went in, by name - the person finds them on the screen by it, and the model reads which ones they were.
+ * Lines of one record share its name; a record without one is only counted.
+ */
+function appliedNames(answer: EntryApplyAnswer, t: (key: string, options?: any) => string): string[] {
+  const names = [...new Set((answer.rows ?? []).filter(row => row.ok && row.label).map(row => row.label as string))]
+  if (!names.length) return []
+  const shown = names.slice(0, 10).join(', ')
+  return [names.length > 10 ? `${shown} ${t('ai-assistant.entry.more-applied', { defaultValue: 'and {count} more', count: names.length - 10 })}` : shown]
 }
 
 /** The handler every entry card runs - built with the mutation so the rules are tested without a server. */
@@ -109,7 +163,7 @@ export function entryProposalHandler(
     /* 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 }
+    const answer = { ...(await apply(context.sessionId, proposal.key, reviewed)), op: proposal.op, key: proposal.key, target: proposal.target }
     if (answer.verdict === 'refused' && answer.errorCode === 'door-closed' && answer.refusal) {
       try {
         await reportRefusal({ level: 'error', message: answer.refusal.message, ex: [answer.refusal] })
@@ -124,7 +178,8 @@ export function entryProposalHandler(
       ...(answer.errorCode ? { errorCode: answer.errorCode } : {}),
       applied: answer.applied ?? 0,
       missed: answer.missed ?? 0,
-      note: entryOutcomeNote(answer, t)
+      note: entryOutcomeNote(answer, t),
+      records: enteredIds(answer)
     }
   }
 }

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

@@ -619,6 +619,9 @@ export declare class OxAssistantChat extends LitElement {
      * (`AssistantSurface.proposalOutcome`), never to run it again. The dock reports what it learns.
      */
     private checkProposal;
+    /** The records each entry card entered - from the conversation's notes, like the outcomes, so a refresh keeps them. */
+    private get entryRecords();
+    private openEntryScreen;
     /** Keys whose run was requested - from the conversation's rows, like the outcomes. */
     private get proposalRequests();
     /**

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

@@ -2,7 +2,7 @@ var OxAssistantChat_1;
 import { __decorate, __metadata } from "tslib";
 import { replyDestination, quotedReply } from './reply-message.js';
 import { rosterName } from './roster-identity';
-import { notify } from '@operato/layout';
+import { entity360KindRegistered, notify } from '@operato/layout';
 import './assistant-invite.js';
 import { TypingRoom } from '../utils/assistant-typing.js';
 import { isInviteProposal, personLine } from '../utils/invite-proposal.js';
@@ -62,11 +62,11 @@ import { buildMentionCandidates, buildCatalogCandidates, buildSlashCandidates, b
  */
 import { chatDefaults } from './chat-defaults.js';
 import { isDifferentConversation, resolveConversation } from './assistant-mode.js';
-import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState } from './proposal-outcome-line.js';
+import { entryWentIn, parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState } from './proposal-outcome-line.js';
 import './entry-review.js';
-import { entryGroupOf, entryReadyCount, entryTitle, isChangeProposal, isEntryProposal, latestEntryKeys } from '../utils/entry-proposal.js';
+import { entryGroupOf, entryReadyCount, entryRecordsOf, entryScreenAddress, 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 { isAppAddress, isOpenPageProposal, openPageNote } from '../utils/open-page.js';
 import { proposalViewOf } from '../utils/assistant-proposals.js';
 function formatFileSize(bytes) {
     if (!bytes || bytes < 1024)
@@ -4117,6 +4117,7 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
         /* The card's state is the conversation's rows - read once for every card of this line. */
         const outcomes = this.proposalOutcomes;
         const requested = this.proposalRequests;
+        const records = this.entryRecords;
         /* A data entry card replaced by a newer one for the same record cannot be entered (design/ai/data-entry.md §5). */
         const latestEntry = items.some(isEntryProposal) ? latestEntryKeys(this.lines.map(one => one.proposals ?? [])) : undefined;
         return html `
@@ -4186,6 +4187,12 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
                                 : i18next.t('ai-assistant.button.run-proposal', { defaultValue: 'run' })}
                     </button>
                   `}
+              ${ /* What went in is seen on its screen - the card's next step once applied, beside its outcome. */''}
+              ${entry && entryWentIn(card) && isAppAddress(p.screen)
+                ? html `<button class="run see" @click=${() => this.openEntryScreen(p, key, records)}>
+                    ${i18next.t('ai-assistant.entry.see-on-screen', { defaultValue: 'see on the screen' })}
+                  </button>`
+                : nothing}
               ${ /*
                 Drawn only where the host has said it staged this candidate, in the host's own
                 words. Not knowing is not a claim: with no word from the host, nothing is drawn.
@@ -4469,6 +4476,22 @@ let OxAssistantChat = class OxAssistantChat extends LitElement {
             composed: true
         }));
     }
+    /** The records each entry card entered - from the conversation's notes, like the outcomes, so a refresh keeps them. */
+    get entryRecords() {
+        const records = new Map();
+        for (const line of this.lines) {
+            if (line.role !== 'system')
+                continue;
+            const entered = entryRecordsOf(line.content ?? '');
+            if (entered)
+                records.set(entered.key, entered.ids);
+        }
+        return records;
+    }
+    openEntryScreen(p, key, records) {
+        const href = entryScreenAddress(p, records.get(key), entity360KindRegistered);
+        this.dispatchEvent(new CustomEvent('assistant-open-page', { detail: { href }, bubbles: true, composed: true }));
+    }
     /** Keys whose run was requested - from the conversation's rows, like the outcomes. */
     get proposalRequests() {
         const requested = new Set();