@things-factory/ai-assistant 10.1.208 → 10.1.212

package/client/components/assistant-session-manager.ts

@@ -13,7 +13,8 @@ import {
   sessionActions,
   type AssistantSessionAdmin,
   type AssistantSessionEntry,
-  type AssistantSessionFilters
+  type AssistantSessionFilters,
+  type SessionVisibility
 } from '../utils/assistant-session-admin.js'
 
 const PAGE = 30
@@ -34,7 +35,7 @@ const t = (key: string, defaultValue: string, options: Record<string, unknown> =
  * with the toolbar's own events and does not open anything itself:
  *   assistant-session-select   { sessionId }    open that conversation
  *   assistant-session-reset                     start a new one
- *   assistant-session-changed  { sessionId, change: 'renamed' | 'hidden' | 'unhidden' | 'removed' | 'visibility' }
+ *   assistant-session-changed  { sessionId, change: 'renamed' | 'hidden' | 'unhidden' | 'removed' | 'visibility' | 'left' }
  *                                               a row changed - the host refreshes its tabs; if the open
  *                                               conversation was removed or hidden, it moves off it
  *
@@ -459,7 +460,7 @@ export class AssistantSessionManager extends LitElement {
     void this.act(entry, hidden ? 'hidden' : 'unhidden', () => this.admin.hide(entry.id, hidden), t('hide-refused', 'this conversation could not be hidden.'))
   }
 
-  private setVisibility(entry: AssistantSessionEntry, visibility: 'open' | 'private') {
+  private setVisibility(entry: AssistantSessionEntry, visibility: SessionVisibility) {
     void this.act(
       entry,
       'visibility',
@@ -497,8 +498,9 @@ export class AssistantSessionManager extends LitElement {
         </select>
         <select aria-label=${t('filter-visibility', 'Visibility')} .value=${this.visibility}
           @change=${(e: Event) => this.refilter(() => (this.visibility = (e.target as HTMLSelectElement).value as any))}>
-          <option value="all">${t('filter-any-visibility', 'Public and private')}</option>
+          <option value="all">${t('filter-any-visibility', 'Anyone')}</option>
           <option value="open">${t('filter-open', 'Public')}</option>
+          <option value="group">${t('filter-group', 'Group')}</option>
           <option value="private">${t('filter-private', 'Private')}</option>
         </select>
         <label><input type="checkbox" .checked=${this.unreadOnly}
@@ -529,7 +531,7 @@ export class AssistantSessionManager extends LitElement {
   private renderRow(entry: AssistantSessionEntry): TemplateResult {
     const name = entry.name || t('untitled', 'Untitled conversation')
     const actions = sessionActions(entry)
-    const isPrivate = entry.visibility === 'private'
+    const isOpen = !entry.visibility || entry.visibility === 'open'
 
     if (this.renamingId === entry.id) {
       return html`<div class="row">
@@ -548,13 +550,13 @@ export class AssistantSessionManager extends LitElement {
     }
 
     return html`<div
-      class="row ${entry.unread ? 'unread' : ''} ${entry.hidden ? 'hidden' : ''} ${entry.id === this.sessionId ? 'current' : ''} ${isPrivate ? '' : 'open-audience'}"
+      class="row ${entry.unread ? 'unread' : ''} ${entry.hidden ? 'hidden' : ''} ${entry.id === this.sessionId ? 'current' : ''} ${isOpen ? 'open-audience' : ''}"
     >
       <span class="dot"></span>
       <button class="open-row" aria-current=${entry.id === this.sessionId ? 'true' : 'false'} @click=${() => this.emit('assistant-session-select', { sessionId: entry.id, kind: entry.kind })}>
         <div class="title">${name}</div>
         <div class="prev">${entry.lastMessagePreview || ''}</div>
-        <span class="meta"><span class="audience ${isPrivate ? 'private' : 'open'}"><md-icon aria-hidden="true">${isPrivate ? 'lock' : 'public'}</md-icon>${isPrivate ? t('audience-private', 'Participants only') : t('audience-open', 'Everyone in this domain')}</span>${entry.lastMessageAt && Number.isFinite(Date.parse(entry.lastMessageAt)) ? html` · <time datetime=${entry.lastMessageAt}>${new Intl.DateTimeFormat(i18next.language || 'en', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }).format(new Date(entry.lastMessageAt))}</time>` : nothing}${entry.mine ? html` · ${t('filter-mine', 'Started by me')}` : nothing}</span>
+        <span class="meta">${this.renderAudience(entry.visibility)}${entry.lastMessageAt && Number.isFinite(Date.parse(entry.lastMessageAt)) ? html` · <time datetime=${entry.lastMessageAt}>${new Intl.DateTimeFormat(i18next.language || 'en', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }).format(new Date(entry.lastMessageAt))}</time>` : nothing}${entry.mine ? html` · ${t('filter-mine', 'Started by me')}` : nothing}</span>
       </button>
       <button
         class="more-menu"
@@ -571,16 +573,21 @@ export class AssistantSessionManager extends LitElement {
   private openRowMenu(event: MouseEvent, entry: AssistantSessionEntry, name: string) {
     event.stopPropagation()
     const actions = sessionActions(entry)
-    const isPrivate = entry.visibility === 'private'
+    const current = entry.visibility || 'open'
     const at = (event.currentTarget as HTMLElement).getBoundingClientRect()
     OxPopupMenu.open({
       template: html`
         ${actions.rename ? html`<ox-popup-menuitem label=${t('rename', 'Rename')} @select=${() => (this.renamingId = entry.id)}></ox-popup-menuitem>` : nothing}
-        ${actions.setVisibility
-          ? isPrivate
-            ? html`<ox-popup-menuitem label=${t('make-open', 'Make public')} @select=${() => this.askOpen(entry, name)}></ox-popup-menuitem>`
-            : html`<ox-popup-menuitem label=${t('make-private', 'Make private')} @select=${() => this.setVisibility(entry, 'private')}></ox-popup-menuitem>`
+        ${actions.setVisibility && current !== 'open'
+          ? html`<ox-popup-menuitem label=${t('make-open', 'Make public')} @select=${() => this.askOpen(entry, name)}></ox-popup-menuitem>`
           : nothing}
+        ${actions.setVisibility && current !== 'group'
+          ? html`<ox-popup-menuitem label=${t('make-group', 'Make it a group')} @select=${() => this.setVisibility(entry, 'group')}></ox-popup-menuitem>`
+          : nothing}
+        ${actions.setVisibility && current !== 'private'
+          ? html`<ox-popup-menuitem label=${t('make-private', 'Make private')} @select=${() => this.askPrivate(entry, name)}></ox-popup-menuitem>`
+          : nothing}
+        ${actions.leave ? html`<ox-popup-menuitem label=${t('leave', 'Leave')} @select=${() => this.askLeave(entry, name)}></ox-popup-menuitem>` : nothing}
         <ox-popup-menuitem
           label=${actions.unhide ? t('unhide', 'Show in my list') : t('hide', 'Hide from my list')}
           @select=${() => this.setHidden(entry, !entry.hidden)}></ox-popup-menuitem>
@@ -620,4 +627,38 @@ export class AssistantSessionManager extends LitElement {
     )
     if (ok) this.setVisibility(entry, 'open')
   }
+
+  /* Private is the owner's alone - the people in it leave, and coming back is being invited again. */
+  private async askPrivate(entry: AssistantSessionEntry, name: string) {
+    const ok = await this.ask(
+      t('make-private', 'Make private'),
+      t('confirm-private', 'Make "{name}" private? Only you will read it, and everyone else in it leaves.', { name }),
+      t('make-private', 'Make private')
+    )
+    if (ok) this.setVisibility(entry, 'private')
+  }
+
+  private async askLeave(entry: AssistantSessionEntry, name: string) {
+    const ok = await this.ask(
+      t('leave', 'Leave'),
+      entry.visibility === 'open'
+        ? t('confirm-leave-open', 'Leave "{name}"? It stops coming to your list.', { name })
+        : t('confirm-leave', 'Leave "{name}"? You will not read it again unless its owner brings you back.', { name }),
+      t('leave', 'Leave')
+    )
+    if (ok) void this.act(entry, 'left', () => this.admin.leave(entry.id), t('leave-refused', 'you could not leave this conversation.'))
+  }
+
+  /** Who reads a conversation, on its row: the same three words wherever a conversation is listed. */
+  private renderAudience(visibility?: string) {
+    const v = visibility || 'open'
+    const icon = v === 'open' ? 'public' : v === 'group' ? 'group' : 'lock'
+    const label =
+      v === 'open'
+        ? t('audience-open', 'Everyone in this domain')
+        : v === 'group'
+          ? t('audience-group', 'Invited people')
+          : t('audience-private', 'Only me')
+    return html`<span class="audience ${v}"><md-icon aria-hidden="true">${icon}</md-icon>${label}</span>`
+  }
 }

package/client/components/proposal-request.test.ts

@@ -50,3 +50,13 @@ it('★ a stored answer brings its cards back after a refresh', () => {
 it('the chat reads stored proposals from history and from the broadcast', () => {
   expect(chat.split('proposalsJson').length - 1).toBeGreaterThanOrEqual(2)
 })
+
+
+it('a failed page-context handoff never sends the request into the previous conversation', () => {
+  const take = body(dock, 'private async takeAsk()')
+  expect(take.indexOf('if (!id) return')).toBeGreaterThan(take.indexOf('await this.startCarried(ask)'))
+  expect(take.indexOf('if (!id) return')).toBeLessThan(take.indexOf('this.asking ='))
+  const carry = body(dock, 'private async startCarried(')
+  expect(carry).toContain('if (created.errors?.length) throw')
+  expect(carry).toContain('if (attached.errors?.length) throw')
+})

package/client/components/roster-identity.test.ts

@@ -1,15 +1,5 @@
-import { rosterInviteState, rosterName } from './roster-identity'
-describe('roster identity and invite notice',()=>{
- it('does not claim denial when participant identities are missing or still loading',()=>{
-  expect(rosterInviteState([{role:'owner'}],'me',true)).toBe('checking')
-  expect(rosterInviteState([], 'me',false)).toBe('checking')
-  expect(rosterInviteState([], undefined,true)).toBe('checking')
- })
- it('uses the current person role rather than another member or a stale loading state',()=>{
-  for(const role of ['owner','member'])expect(rosterInviteState([{role,user:{id:'me'}}],'me',true)).toBe('allowed')
-  expect(rosterInviteState([{role:'viewer',user:{id:'me'}},{role:'owner',user:{id:'other'}}],'me',true)).toBe('denied')
-  expect(rosterInviteState([{role:'member',user:{id:'other'}}],'me',true)).toBe('denied')
- })
+import { rosterName } from './roster-identity'
+describe('roster identity',()=>{
  it('shows a recognizable full name, then username, then an explicit unavailable label',()=>{
   expect(rosterName({role:'member',user:{id:'u',name:' 정연희 '}},'Unavailable')).toBe('정연희')
   expect(rosterName({role:'member',user:{id:'u',username:'yeonhee'}},'Unavailable')).toBe('yeonhee')

package/client/components/roster-identity.ts

@@ -1,10 +1,4 @@
 export interface RosterParticipant { role: string; user?: { id: string; name?: string; username?: string } }
-/** Missing identity/loading is not evidence that a person lacks membership. Server gates remain authoritative. */
-export function rosterInviteState(rows: readonly RosterParticipant[], userId: string | undefined, loaded: boolean): 'checking' | 'allowed' | 'denied' {
-  if (!loaded || !userId || rows.some(row => !row.user?.id)) return 'checking'
-  const role = rows.find(row => row.user?.id === userId)?.role
-  return role === 'owner' || role === 'member' ? 'allowed' : 'denied'
-}
 export function rosterName(person: RosterParticipant, fallback: string): string {
   return person.user?.name?.trim() || person.user?.username?.trim() || fallback
 }

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

@@ -6,6 +6,7 @@
  *   hide/unhide   anyone, for their own list only (reversible)
  *   delete        the creator (`mine`)            (not reversible from a screen)
  *   visibility    the owner (`owner`)             (opening shows what is already written)
+ *   leave         a participant who is not the owner (the owner deletes or makes it private instead)
  */
 export function sessionActions(entry: { participant?: boolean; hidden?: boolean; mine?: boolean; owner?: boolean }) {
   return {
@@ -13,6 +14,7 @@ export function sessionActions(entry: { participant?: boolean; hidden?: boolean;
     hide: !entry.hidden,
     unhide: !!entry.hidden,
     remove: !!entry.mine,
-    setVisibility: !!entry.owner
+    setVisibility: !!entry.owner,
+    leave: !!entry.participant && !entry.owner
   }
 }

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

@@ -17,9 +17,11 @@ export { sessionActions } from './assistant-session-actions.js'
  *   hide/unhide   anyone, for their own list only (reversible)
  *   delete        the creator (`mine`)            (not reversible from a screen)
  *   visibility    the owner (`owner`)             (opening shows what is already written)
+ *   leave         a member, never the owner       (in a group, leaving ends reading here)
  */
 
-export type SessionVisibility = 'open' | 'private'
+/** Who reads it: everyone in the domain, the people the owner brought in, or the owner alone (ADR-0073 decision 3). */
+export type SessionVisibility = 'open' | 'group' | 'private'
 
 /** One row of `chatSessionInbox`, as the list draws it. */
 export interface AssistantSessionEntry {
@@ -48,7 +50,7 @@ export interface AssistantSessionFilters {
   /** A kind (mode) to list; empty lists every kind on the anchor. */
   kind?: string
   whose?: 'all' | 'mine' | 'participant'
-  visibility?: 'all' | 'open' | 'private'
+  visibility?: 'all' | SessionVisibility
   includeHidden?: boolean
   unreadOnly?: boolean
 }
@@ -77,6 +79,7 @@ export interface AssistantSessionAdmin {
   hide(sessionId: string, hidden: boolean): Promise<boolean>
   remove(sessionId: string): Promise<boolean>
   setVisibility(sessionId: string, visibility: SessionVisibility): Promise<boolean>
+  leave(sessionId: string): Promise<boolean>
 }
 
 /** The page size the server allows at most (`chatSessionInbox` clamps to 200). */
@@ -163,5 +166,9 @@ export const assistantSessionAdmin: AssistantSessionAdmin = {
       { id: sessionId, v: visibility },
       'setSessionVisibility'
     )
+  },
+
+  leave(sessionId) {
+    return mutate(gql`mutation ($id: String!) { leaveAISession(sessionId: $id) }`, { id: sessionId }, 'leaveAISession')
   }
 }

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

@@ -11,7 +11,7 @@ export interface AssistantSession {
    * 칸이 서기 전에 난 세션에는 값이 없다. 그때는 지금 대화로 두고, 서버가 다음 턴에 찍는다.
    */
   kind?: string
-  /** Who reads it: 'open' (everyone in the domain) or 'private' (participants). The dock draws an open one apart. */
+  /** Who reads it: 'open' (everyone in the domain), 'group' (the people the owner brought in) or 'private' (the owner alone). The dock draws an open one apart. */
   visibility?: string
 }
 export interface AssistantSessionTarget {

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

@@ -0,0 +1,33 @@
+import { TYPING_SAY_EVERY_MS, TYPING_SHOW_MS, TypingRoom } from './assistant-typing'
+
+describe('typing in a conversation', () => {
+  it('says it with words in the box, not on every key', () => {
+    const room = new TypingRoom()
+    expect(room.shouldSay('', 0)).toBe(false)
+    expect(room.shouldSay('h', 10_000)).toBe(true)
+    expect(room.shouldSay('he', 10_000 + TYPING_SAY_EVERY_MS - 1)).toBe(false)
+    expect(room.shouldSay('hel', 10_000 + TYPING_SAY_EVERY_MS)).toBe(true)
+  })
+
+  it('★ a notice fades without the next one', () => {
+    const room = new TypingRoom()
+    room.heard({ userId: 'u2', name: 'Kim' }, 0)
+    expect(room.typing(TYPING_SHOW_MS - 1)).toEqual(['Kim'])
+    expect(room.typing(TYPING_SHOW_MS)).toEqual([])
+  })
+
+  it('★ the message ends it at once', () => {
+    const room = new TypingRoom()
+    room.heard({ userId: 'u2', name: 'Kim' }, 0)
+    room.heard({ userId: 'u3', name: 'Lee' }, 0)
+    expect(room.spoke('u2')).toBe(true)
+    expect(room.typing(1)).toEqual(['Lee'])
+  })
+
+  it('a new notice from the same person keeps one line for them', () => {
+    const room = new TypingRoom()
+    room.heard({ userId: 'u2', name: 'Kim' }, 0)
+    room.heard({ userId: 'u2', name: 'Kim' }, TYPING_SHOW_MS - 1)
+    expect(room.typing(TYPING_SHOW_MS + 1)).toEqual(['Kim'])
+  })
+})

package/client/utils/assistant-typing.ts

@@ -0,0 +1,53 @@
+/*
+ * "Someone is typing" on the client - when to say it, and whose to show. Pure, so it is tested alone
+ * (`assistant-typing.test.ts`); the chat sends and receives, this keeps the times.
+ *
+ * Nothing is stored on the server, so a notice stands only until the next would have come: the typist says it
+ * every few seconds while the words change, the room lets it fade a little after the last one, and a message
+ * from that person ends it at once - the words arrived.
+ */
+
+/** How often a typist says it while typing. */
+export const TYPING_SAY_EVERY_MS = 3_000
+
+/** How long a notice stands without the next - the server's `TYPING_NOTICE_MS`. */
+export const TYPING_SHOW_MS = 6_000
+
+export interface TypingNotice {
+  userId: string
+  name: string
+}
+
+export class TypingRoom {
+  private saidAt = 0
+  private heardFrom = new Map<string, { name: string; until: number }>()
+
+  /** Should the typist say it now? Only with words in the box, and not more often than every few seconds. */
+  shouldSay(text: string, now = Date.now()): boolean {
+    if (!text.trim()) return false
+    if (now - this.saidAt < TYPING_SAY_EVERY_MS) return false
+    this.saidAt = now
+    return true
+  }
+
+  heard(notice: TypingNotice, now = Date.now()): void {
+    if (!notice?.userId) return
+    this.heardFrom.set(notice.userId, { name: notice.name, until: now + TYPING_SHOW_MS })
+  }
+
+  /** That person's message arrived - they are not typing it any more. */
+  spoke(userId: string | undefined): boolean {
+    return !!userId && this.heardFrom.delete(userId)
+  }
+
+  /** The names typing now, in the order they started; faded ones are dropped. */
+  typing(now = Date.now()): string[] {
+    for (const [id, one] of this.heardFrom) if (one.until <= now) this.heardFrom.delete(id)
+    return [...this.heardFrom.values()].map(one => one.name)
+  }
+
+  clear(): void {
+    this.saidAt = 0
+    this.heardFrom.clear()
+  }
+}

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

@@ -1,3 +1,4 @@
+import './assistant-invite.js';
 /**
  * <ox-assistant-chat> — AI 도우미 채팅 컴포넌트 (Lit).
  *
@@ -41,6 +42,8 @@ export declare class OxAssistantChat extends LitElement {
     /** 영속 세션 id. 없으면 ad-hoc (메시지 영속 안 됨). */
     sessionId?: string;
     prepareSession?: (adopt: (id: string) => void) => Promise<string | undefined>;
+    /** Who reads this conversation - 'open' · 'group' · 'private'. The host passes what its list says; the roster follows it. */
+    visibility?: string;
     private adoptingSession;
     /**
      * 보드의 모든 ChatSession 리스트 — 다중 세션 활성화 시 탭 UI 로 표시.
@@ -310,6 +313,15 @@ export declare class OxAssistantChat extends LitElement {
     /** C4 presence/roster — 세션 참여자 목록. lastSeenAt 으로 online 판정. */
     private participants;
     private rosterLoaded;
+    /** May I bring someone in here - the server's answer (`mayInviteToAISession`); unknown until the roster is read. */
+    private mayInvite?;
+    /** The name box under the roster is open. */
+    private inviting;
+    /** Who is typing now, by name - kept by `typingRoom`, redrawn on each notice and as they fade. */
+    private typingNames;
+    private typingRoom;
+    private _typingSub?;
+    private _typingTimer?;
     /** roster online 재평가 트리거 — heartbeat tick 마다 갱신(시간 경과 반영). */
     private _presenceTick;
     private _heartbeatTimer?;
@@ -390,6 +402,9 @@ export declare class OxAssistantChat extends LitElement {
     private _startPresence;
     private _stopPresence;
     private _startMessageSubscription;
+    /** The room's "typing" line - notices of the others, which fade by themselves (`TypingRoom`). */
+    private _startTypingSubscription;
+    private _refreshTyping;
     private _stopMessageSubscription;
     /** 서버 ChatMessage → ChatLine. */
     private _msgToLine;
@@ -494,7 +509,20 @@ export declare class OxAssistantChat extends LitElement {
     private renderAgentPicker;
     private renderSessionTabs;
     /** C4 roster — 세션 참여자 + online 표시. 참여자 2명 미만이면 숨김(혼자면 의미 없음). */
+    /**
+     * Who is in the room. A group shows it always - its people are the point of it, and the owner brings them in
+     * here; any other room once someone else has joined. The buttons follow what the server said this person may
+     * do (`mayInviteToAISession`, the owner's role); the doors decide again.
+     */
     private renderRoster;
+    /** Bring someone in - the door seats them and tells them (`inviteToAISession`). */
+    private _invite;
+    /** Send a member out - in a group they no longer read or write here. Bringing them back is inviting them again. */
+    private _removeParticipant;
+    /** Tell the others I am typing - only where someone else could hear it, and not on every key (`TypingRoom`). */
+    private _sayTyping;
+    /** "Kim is typing…" - over the box, while their notices keep coming. */
+    private renderTyping;
     private _onSessionTabClick;
     private _onSessionCreateClick;
     private renderEmpty;