@things-factory/ai-assistant 10.1.214 → 10.1.215

package/server/service/chat-session-resolver.ts

@@ -10,11 +10,12 @@ import { User } from '@things-factory/auth-base'
 import { buildDomainUsersQueryBuilder } from '@things-factory/auth-base/dist-server/utils/get-domain-users.js'
 
 import { getRepository, pubsub } from '@things-factory/shell'
-import { In, Like } from 'typeorm'
+import { config } from '@things-factory/env'
+import { In, IsNull, Like, Not } from 'typeorm'
 
 import { ChatSession } from './chat-session/chat-session.js'
 import { anchorColumns, anchorWhere } from './chat-session/session-anchor.js'
-import { buildInbox, applyHidden, activityPatch, searchInbox, filterInbox, searchReadableMessages, INBOX_SCAN_CAP, type InboxFilter } from './chat-session/session-inbox.js'
+import { buildInbox, applyHidden, activityPatch, listedEntries, searchInbox, filterInbox, searchReadableMessages, INBOX_SCAN_CAP, type InboxFilter } from './chat-session/session-inbox.js'
 import { carriedOriginalWhere, planCarriedTurns, quoteCarriedAnswer } from './chat-message/carried-turns.js'
 import { roomMessageBody } from './chat-message/room-message.js'
 import { readerGate } from './chat-message/reader-gate.js'
@@ -26,6 +27,17 @@ import { sendInviteNotification } from './chat-session-participant/invite-notifi
 import { readRoster } from './chat-session-participant/read-roster.js'
 import { isSessionParticipant } from './chat-session-participant/participant-lookup.js'
 import { assertMayWriteSession } from './chat-session/session-write-gate.js'
+import { archiveDaysOf, cleanupReason, idleDays, isArchived } from './chat-session/session-cleanup.js'
+import { DAY_MS, retentionDaysOf } from './chat-session/session-retention.js'
+
+/** The keeping periods the config asks for (shared-dock.md §9-5, §2-7). */
+function keeping(): { deletedDays: number | null; archiveDays: number | null } {
+  const options = config.get('ai-assistant', {}) ?? {}
+  return { deletedDays: retentionDaysOf(options.sessionRetentionDays), archiveDays: archiveDaysOf(options.sessionArchiveDays) }
+}
+
+/** One request reads the list once - the list, its total and its counts ask together and share it. */
+const inboxReads = new WeakMap<object, Map<string, Promise<any[]>>>()
 
 /** 초대 알림 — 발송은 호스트의 기전을 그대로 쓴다(`sendInviteNotification`, 문 셋이 같은 한 곳). */
 async function notifyInvited(context: any, invited: string[], inviter: any, sessionName?: string): Promise<void> {
@@ -129,6 +141,43 @@ class ChatSessionInboxEntry {
 
   @Field({ description: 'Whether this viewer is the owner of the session - only the owner may change its visibility.' })
   owner!: boolean
+
+  /* No activity for the archive period: out of the list until asked for or searched. A new message brings it back. */
+  @Field({ nullable: true, description: 'Whether the session has had no activity for the archive period (config sessionArchiveDays, default 60) - left out of the list unless includeArchived or a search asks for it.' })
+  archived?: boolean
+
+  @Field({ nullable: true, description: "Why the list suggests clearing this session: 'empty' (never asked anything) or 'inactive' (no activity for 30 days). Only on sessions this viewer created." })
+  cleanupReason?: string
+
+  @Field(type => Int, { nullable: true, description: 'Whole days since the last activity, or since the start when there is none.' })
+  idleDays?: number
+}
+
+@ObjectType({ description: 'A session the caller deleted that is still kept - it can be brought back until it is emptied.' })
+class DeletedSessionEntry {
+  @Field(type => ID, { description: 'Session id.' })
+  id!: string
+
+  @Field({ nullable: true, description: 'Session name.' })
+  name?: string
+
+  @Field({ nullable: true, description: 'Which conversation this session is - the registered mode kind.' })
+  kind?: string
+
+  @Field({ description: 'When it was deleted.' })
+  deletedAt!: Date
+
+  @Field({ nullable: true, description: 'When the daily job empties it for good; none when emptying is turned off.' })
+  purgesAt?: Date
+}
+
+@ObjectType({ description: 'How long conversations are kept - what the list says when it deletes or archives.' })
+class SessionKeeping {
+  @Field(type => Int, { nullable: true, description: 'Days a deleted session can still be brought back; none when deleted sessions are never emptied.' })
+  deletedDays?: number
+
+  @Field(type => Int, { nullable: true, description: 'Days without activity after which a session is archived; none when archiving is off.' })
+  archiveDays?: number
 }
 
 @ObjectType({ description: 'A file stored with a conversation - opened only through the conversation.' })
@@ -230,10 +279,12 @@ export class ChatSessionResolver {
     @Arg('kind', { nullable: true, description: 'Only this conversation kind (mode).' }) kind?: string,
     @Arg('participantOnly', { nullable: true, description: 'Only conversations the caller is in.' }) participantOnly?: boolean,
     @Arg('visibility', { nullable: true, description: "Only 'open' or only 'private'." }) visibility?: string,
-    @Arg('unreadOnly', { nullable: true, description: 'Only conversations with unread activity.' }) unreadOnly?: boolean
+    @Arg('unreadOnly', { nullable: true, description: 'Only conversations with unread activity.' }) unreadOnly?: boolean,
+    @Arg('includeArchived', { nullable: true, description: 'Also the archived ones - no activity for the archive period.' }) includeArchived?: boolean,
+    @Arg('cleanupOnly', { nullable: true, description: "Only the caller's own the list suggests clearing (empty, or inactive for 30 days), hidden and archived ones included." }) cleanupOnly?: boolean
   ): Promise<ChatSessionInboxEntry[]> {
     const filtered = await this._inboxFiltered(anchorType, anchorId, context, {
-      showHidden, search, mineOnly, kind, participantOnly, visibility, unreadOnly
+      showHidden, search, mineOnly, kind, participantOnly, visibility, unreadOnly, includeArchived, cleanupOnly
     })
     const from = Math.max(0, offset ?? 0)
     const size = Math.min(Math.max(1, limit ?? 50), 200)
@@ -261,10 +312,14 @@ export class ChatSessionResolver {
     @Arg('kind', { nullable: true, description: 'Only this conversation kind (mode).' }) kind?: string,
     @Arg('participantOnly', { nullable: true, description: 'Only conversations the caller is in.' }) participantOnly?: boolean,
     @Arg('visibility', { nullable: true, description: "Only 'open' or only 'private'." }) visibility?: string,
-    @Arg('unreadOnly', { nullable: true, description: 'Only conversations with unread activity.' }) unreadOnly?: boolean
+    @Arg('unreadOnly', { nullable: true, description: 'Only conversations with unread activity.' }) unreadOnly?: boolean,
+    @Arg('includeArchived', { nullable: true, description: 'Also the archived ones - no activity for the archive period.' }) includeArchived?: boolean,
+    @Arg('cleanupOnly', { nullable: true, description: "Only the caller's own the list suggests clearing." }) cleanupOnly?: boolean
   ): Promise<number> {
     return (
-      await this._inboxFiltered(anchorType, anchorId, context, { showHidden, search, mineOnly, kind, participantOnly, visibility, unreadOnly })
+      await this._inboxFiltered(anchorType, anchorId, context, {
+        showHidden, search, mineOnly, kind, participantOnly, visibility, unreadOnly, includeArchived, cleanupOnly
+      })
     ).length
   }
 
@@ -273,10 +328,10 @@ export class ChatSessionResolver {
     anchorType: string,
     anchorId: string,
     context: ResolverContext,
-    opts: { showHidden?: boolean; search?: string } & InboxFilter
+    opts: { showHidden?: boolean; search?: string; includeArchived?: boolean; cleanupOnly?: boolean } & InboxFilter
   ): Promise<ChatSessionInboxEntry[]> {
     const all = await this._inboxEntries(anchorType, anchorId, context)
-    let entries = opts.showHidden ? all : all.filter(e => !e.hidden)
+    let entries = listedEntries(all, opts)
     entries = filterInbox(entries as any, opts) as any
     if (!opts.search?.trim() || !entries.length) return entries
     // Search only readable rooms, then pass their messages through the SAME reader gate.
@@ -315,8 +370,81 @@ export class ChatSessionResolver {
     return all.filter(e => e.hidden).length
   }
 
+  /* Like the hidden count: an archived conversation must not be forgotten, so the list says how many wait there. */
+  @Query(() => Int, { description: 'Number of sessions on this anchor that are archived (no activity for the archive period) and not hidden by the caller.' })
+  @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
+  async archivedSessionCount(@Arg('anchorType') anchorType: string, @Arg('anchorId') anchorId: string, @Ctx() context: ResolverContext): Promise<number> {
+    return (await this._inboxEntries(anchorType, anchorId, context)).filter(e => e.archived && !e.hidden).length
+  }
+
+  @Query(() => Int, { description: "Number of the caller's own sessions on this anchor the list suggests clearing - empty, or inactive for 30 days." })
+  @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
+  async cleanupSessionCount(@Arg('anchorType') anchorType: string, @Arg('anchorId') anchorId: string, @Ctx() context: ResolverContext): Promise<number> {
+    return (await this._inboxEntries(anchorType, anchorId, context)).filter(e => e.cleanupReason).length
+  }
+
+  @Query(() => SessionKeeping, { description: 'How long deleted sessions can be brought back and after how long an idle one is archived.' })
+  @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
+  aiSessionKeeping(): SessionKeeping {
+    const { deletedDays, archiveDays } = keeping()
+    return { deletedDays: deletedDays ?? undefined, archiveDays: archiveDays ?? undefined }
+  }
+
+  /** What I deleted here and can still bring back - newest first. Only the creator deletes, so only the creator sees them. */
+  @Query(() => [DeletedSessionEntry], { description: 'Sessions on this anchor that the caller deleted and that are still kept, newest deletion first. They can be brought back with restoreAISession until they are emptied.' })
+  @Directive('@privilege(category: "ai-assistant", privilege: "query", domainOwnerGranted: true)')
+  async deletedAISessions(@Arg('anchorType') anchorType: string, @Arg('anchorId') anchorId: string, @Ctx() context: ResolverContext): Promise<DeletedSessionEntry[]> {
+    const { domain, user } = context.state
+    if (!user?.id) return []
+    const { deletedDays } = keeping()
+    const rows = await getRepository(ChatSession).find({
+      where: { ...anchorWhere(domain.id, anchorType, anchorId), creator: { id: user.id }, deletedAt: Not(IsNull()) } as any,
+      withDeleted: true,
+      order: { deletedAt: 'DESC' } as any,
+      take: INBOX_SCAN_CAP
+    })
+    return rows.map(row => ({
+      id: row.id!,
+      name: (row as any).name ?? undefined,
+      kind: (row as any).kind ?? undefined,
+      deletedAt: (row as any).deletedAt,
+      purgesAt: deletedDays === null ? undefined : new Date(new Date((row as any).deletedAt).getTime() + deletedDays * DAY_MS)
+    }))
+  }
+
+  /** Bringing a deleted conversation back - its creator, while it is kept. Its messages and seats were never touched. */
+  @Mutation(() => Boolean, { description: 'Bring back a session the caller deleted, while it is still kept (before the daily job empties it). Creator only, like deleting.' })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
+  async restoreAISession(@Arg('sessionId') sessionId: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, user } = context.state
+    const repo = getRepository(ChatSession)
+    const session = await repo.findOne({ where: { id: sessionId, domain: { id: domain.id } } as any, withDeleted: true })
+    if (!session || !(session as any).deletedAt) return false
+    if (!user?.id || (session as any).creatorId !== user.id) {
+      throw new Error('Only the user who created this session may bring it back.')
+    }
+    await repo.restore(sessionId)
+    publishSessionActivity({
+      domainId: domain.id,
+      sessionId,
+      kind: 'meta',
+      anchorType: (session as any).anchorType,
+      anchorId: (session as any).anchorId,
+      actorId: user.id
+    })
+    return true
+  }
+
   /** 목록 조립 — 숨김 표시까지 붙인 **전체**. 목록·개수 두 진입점이 같은 규칙을 쓰도록 한 곳에 둔다. */
-  private async _inboxEntries(
+  private _inboxEntries(anchorType: string, anchorId: string, context: ResolverContext): Promise<ChatSessionInboxEntry[]> {
+    const reads = inboxReads.get(context) ?? new Map<string, Promise<any[]>>()
+    inboxReads.set(context, reads)
+    const key = `${anchorType}\u0000${anchorId}`
+    if (!reads.has(key)) reads.set(key, this._readInbox(anchorType, anchorId, context))
+    return reads.get(key)!
+  }
+
+  private async _readInbox(
     anchorType: string,
     anchorId: string,
     context: ResolverContext
@@ -339,10 +467,18 @@ export class ChatSessionResolver {
     const hiddenAt = new Map(rows.map(r => [(r as any).sessionId as string, r.hiddenAt]))
     /* 내가 만든 대화인지 표시 — 삭제 버튼을 보일지 결정하는 UI 힌트(권한은 서버가 다시 판정한다). */
     const createdByMe = new Set(sessions.filter(s => (s as any).creatorId === user?.id).map(s => s.id))
-    const entries = buildInbox(sessions as any, participations as any).map(entry => ({
-      ...entry,
-      mine: createdByMe.has(entry.id)
-    }))
+    const now = new Date()
+    const { archiveDays } = keeping()
+    const entries = buildInbox(sessions as any, participations as any).map(entry => {
+      const mine = createdByMe.has(entry.id)
+      return {
+        ...entry,
+        mine,
+        idleDays: idleDays(entry, now),
+        archived: isArchived(entry, now, archiveDays),
+        cleanupReason: cleanupReason({ ...entry, mine }, now) ?? undefined
+      }
+    })
     /* showHidden=true 로 불러 **전체**를 얻는다 — 숨김 여부 판정을 두 곳에 복제하지 않기 위함. */
     const shown = applyHidden(entries as any, hiddenAt, true) as any[]
 
@@ -374,7 +510,7 @@ export class ChatSessionResolver {
    */
   @Mutation(() => Boolean, {
     description:
-      'Delete a chat session — creator only, since a shared deliberation cannot be un-deleted from the UI. Participants who are not the creator can hide it from their own list instead (hideAISession). Soft delete; broadcast as meta activity so every list drops it.'
+      'Delete a chat session — creator only, since it disappears for every participant. Participants who are not the creator can hide it from their own list instead (hideAISession). Soft delete: the creator can bring it back with restoreAISession until the daily job empties it (sessionRetentionDays). Broadcast as meta activity so every list drops it.'
   })
   @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
   async deleteAISession(@Arg('sessionId') sessionId: string, @Ctx() context: ResolverContext): Promise<boolean> {

package/server/service/data-read/list-read.ts

@@ -23,7 +23,7 @@ export interface ListRead {
   dateField?: string
   /** Integer year and month fields, and an in/out field (INCOME | EXPENSE) - the `year`, `month`, `flow` conditions. */
   narrowing?: { year?: string; month?: string; flow?: string }
-  /** A field holding the period as YYYY-MM - the `period` condition. */
+  /** A field holding the period as YYYY-MM - the `period` condition, and `periodFrom` / `periodTo` for a range of months. */
   monthField?: string
   /** A status field and its values - the `status` condition. */
   status?: { field: string; values: string[] }
@@ -39,6 +39,8 @@ export interface ListRead {
    * searched the asker's own name (2026-10-24).
    */
   missing?: { name: string; description: string; filters: ReadFilter[] }[]
+  /** The rows are the person's own, whoever reads them (`myExpenditureRequests`) - ReadTarget.mine. */
+  mine?: boolean
 }
 
 /** The money column a minimum or maximum amount means - `amount` when there is one, else the first summed column. */
@@ -63,10 +65,34 @@ export function listReadTarget(list: ListRead): ReadTarget {
       ? [{ name: 'flow', type: 'enum', values: ['INCOME', 'EXPENSE'], labelKey: 'ai-assistant.read.flow', description: 'money in or out', filter: (v: any) => ({ name: narrowing.flow!, operator: 'eq', value: v }) }]
       : []),
     ...(list.monthField
-      ? [{ name: 'period', type: 'string', labelKey: 'ai-assistant.read.period', description: 'a month as YYYY-MM', filter: (v: any) => ({ name: list.monthField!, operator: 'eq', value: v }) }]
+      ? [
+          { name: 'period', type: 'string', format: 'month', labelKey: 'ai-assistant.read.period', description: 'a month as YYYY-MM', filter: (v: any) => ({ name: list.monthField!, operator: 'eq', value: v }) },
+          /* A range of months - "the last six months" of a list kept by month (2026-10-25: only one fixed month could be read). */
+          { name: 'periodFrom', type: 'string', format: 'month', labelKey: 'ai-assistant.read.period-from', description: 'the first month, inclusive, as YYYY-MM', filter: (v: any) => ({ name: list.monthField!, operator: 'gte', value: v }) },
+          { name: 'periodTo', type: 'string', format: 'month', labelKey: 'ai-assistant.read.period-to', description: 'the last month, inclusive, as YYYY-MM', filter: (v: any) => ({ name: list.monthField!, operator: 'lte', value: v }) }
+        ]
       : []),
     ...(list.status
-      ? [{ name: 'status', type: 'enum', values: list.status.values, labelKey: 'ai-assistant.read.status', filter: (v: any) => ({ name: list.status!.field, operator: 'eq', value: v }) }]
+      ? [
+          {
+            name: 'status',
+            type: 'enum',
+            values: list.status.values,
+            many: true,
+            labelKey: 'ai-assistant.read.status',
+            description: 'the statuses to read',
+            filter: (v: any) => (Array.isArray(v) && v.length > 1 ? { name: list.status!.field, operator: 'in', value: v } : { name: list.status!.field, operator: 'eq', value: [v].flat()[0] })
+          },
+          {
+            name: 'statusNot',
+            type: 'enum',
+            values: list.status.values,
+            many: true,
+            labelKey: 'ai-assistant.read.status-not',
+            description: 'the statuses to leave out - every other status is read',
+            filter: (v: any) => ({ name: list.status!.field, operator: 'notin', value: [v].flat() })
+          }
+        ]
       : []),
     ...(list.missing?.length
       ? [
@@ -101,6 +127,7 @@ export function listReadTarget(list: ListRead): ReadTarget {
     criteria,
     ...(list.fixedFilters?.length ? { fixedFilters: list.fixedFilters } : {}),
     columns: list.columns,
+    ...(list.mine ? { mine: true } : {}),
     rowsOf: data => ({ rows: data?.[list.listQuery]?.items ?? [], total: data?.[list.listQuery]?.total ?? 0 }),
     ...(search ? { search: { description: `the ${list.search}` } } : {}),
     ...(list.dateField ? { sortings: [{ name: list.dateField, desc: true }] } : {}),

package/server/service/data-read/list-status.test.ts

@@ -0,0 +1,46 @@
+/*
+ * A list's status condition takes several statuses, and the statuses to leave out (2026-10-25): asked for the
+ * expenditure requests not approved, rejected or withdrawn, the model read the list once per status and stopped.
+ */
+import { listReadTarget } from './list-read'
+import { filtersOf, readCriteria } from './read-target'
+
+const target = listReadTarget({
+  key: 'office.expenditure-request',
+  title: 'menu.expenditure-request-list',
+  name: '지출결의',
+  listQuery: 'expenditureRequests',
+  selection: 'id status totalAmount',
+  columns: [
+    { name: 'status', type: 'string' },
+    { name: 'totalAmount', type: 'number', total: true }
+  ],
+  status: { field: 'status', values: ['DRAFT', 'SUBMITTED', 'APPROVED', 'REJECTED', 'WITHDRAWN'] }
+})
+const filters = (args: any) => {
+  const { criteria, refused } = readCriteria(target, args)
+  return refused.length ? { refused } : filtersOf(target, criteria)
+}
+
+describe('a status condition', () => {
+  it('★ one status is eq, several are in', () => {
+    expect(filters({ status: 'SUBMITTED' })).toEqual([{ name: 'status', operator: 'eq', value: 'SUBMITTED' }])
+    expect(filters({ status: ['SUBMITTED'] })).toEqual([{ name: 'status', operator: 'eq', value: 'SUBMITTED' }])
+    expect(filters({ status: ['DRAFT', 'SUBMITTED'] })).toEqual([{ name: 'status', operator: 'in', value: ['DRAFT', 'SUBMITTED'] }])
+  })
+
+  it('★ the statuses to leave out are notin - every other status is read', () => {
+    expect(filters({ statusNot: ['APPROVED', 'REJECTED', 'WITHDRAWN'] })).toEqual([{ name: 'status', operator: 'notin', value: ['APPROVED', 'REJECTED', 'WITHDRAWN'] }])
+    expect(filters({ statusNot: 'APPROVED' })).toEqual([{ name: 'status', operator: 'notin', value: ['APPROVED'] }])
+  })
+
+  it('a status the list does not have is refused, in a list too', () => {
+    expect(filters({ statusNot: ['APPROVED', 'PAID'] })).toEqual({ refused: [{ name: 'statusNot', code: 'not-in-list' }] })
+    expect(filters({ status: ['NOPE'] })).toEqual({ refused: [{ name: 'status', code: 'not-in-list' }] })
+  })
+
+  it('a condition that takes one value refuses a list', () => {
+    const { refused } = readCriteria(target, { minAmount: [1, 2] })
+    expect(refused).toEqual([{ name: 'minAmount', code: 'one-value' }])
+  })
+})

package/server/service/data-read/read-target.ts

@@ -23,6 +23,13 @@ export interface ReadFilter {
 /** A condition the model may set - read with the entry fields' rules, turned into the query's filters by the application. */
 export interface ReadCriterion extends Omit<EntryField, 'required' | 'reference' | 'total'> {
   filter: (value: any) => ReadFilter | ReadFilter[]
+  /** A string condition holding a month as YYYY-MM - a value of another shape is refused (`not-a-month`). */
+  format?: 'month'
+  /**
+   * The condition takes several values at once - its filter is given the list. Asked for the expenditure requests not
+   * approved, rejected or withdrawn, the model read the list once per status and stopped (2026-10-25).
+   */
+  many?: boolean
 }
 
 export interface ReadColumn {
@@ -81,6 +88,11 @@ export interface ReadTarget {
   /** Orders the rows; the query's own order when left out. */
   sortings?: { name: string; desc?: boolean }[]
   screen?: ReadScreen
+  /**
+   * The rows are the person's own, whoever reads them (내 지출결의) - the query answers for the one asking. A dashboard
+   * card of it shows each viewer their own rows and takes no filter on a person (ADR-0160).
+   */
+  mine?: boolean
 }
 
 /** At most this many rows are read - the AI 작업판 table's own limit (workspace-blocks MAX_TABLE_ROWS). */
@@ -165,6 +177,8 @@ export interface DetailArg {
   required?: boolean
   /** A record's id: the axis (or axes) of the record, whose key `<axis>:<id>` the model may have been shown (EntryField.axis). */
   axis?: string | readonly string[]
+  /** A string argument holding a month as YYYY-MM. */
+  format?: 'month'
 }
 
 /**
@@ -192,6 +206,8 @@ export interface DetailRead {
    * (ADR-0160 decision 2). The card keeps only `key`; where the rows are and what their columns are is read here.
    */
   lists?: DetailList[]
+  /** The answer is the person's own, whoever asks (나의 전략 업무, 내 급여) - ReadTarget.mine. */
+  mine?: boolean
 }
 
 /** A list inside a detail read's answer. */
@@ -248,6 +264,9 @@ export function detailReadOf(key: string | undefined): DetailRead | undefined {
   return key ? details.get(key) : undefined
 }
 
+/** A month as a `month` condition holds it. */
+const MONTH = /^\d{4}-(0[1-9]|1[0-2])$/
+
 /** The conditions the model set, read by their declared types; a value that does not fit is said, never guessed at. */
 export function readCriteria(target: ReadTarget, args: any): { criteria: Record<string, unknown>; refused: { name: string; code: string }[] } {
   const criteria: Record<string, unknown> = {}
@@ -257,9 +276,21 @@ export function readCriteria(target: ReadTarget, args: any): { criteria: Record<
   if (target.search && typeof args?.text === 'string' && args.text.trim()) criteria.text = args.text.trim()
   for (const criterion of target.criteria) {
     const value = args?.[criterion.name]
-    if (value === undefined || value === null || value === '') continue
+    if (value === undefined || value === null || value === '' || (Array.isArray(value) && !value.length)) continue
+    if (criterion.many && Array.isArray(value)) {
+      const each = value.map(one => readFieldValue(criterion as EntryField, one))
+      const wrong = each.find(one => one.read === undefined)
+      if (wrong) refused.push({ name: criterion.name, code: wrong.code ?? 'unreadable' })
+      else criteria[criterion.name] = [...new Set(each.map(one => one.read))]
+      continue
+    }
+    if (Array.isArray(value)) {
+      refused.push({ name: criterion.name, code: 'one-value' })
+      continue
+    }
     const { read, code } = readFieldValue(criterion as EntryField, value)
     if (read === undefined) refused.push({ name: criterion.name, code: code ?? 'unreadable' })
+    else if (criterion.format === 'month' && !MONTH.test(String(read))) refused.push({ name: criterion.name, code: 'not-a-month' })
     else criteria[criterion.name] = read
   }
   return { criteria, refused }

package/server/service/data-read/read-tools.ts

@@ -48,9 +48,10 @@ const wordsOf = (context: any) => (key: string | undefined, fallback: string) =>
 function criterionSchema(criterion: ReadCriterion): any {
   /* One type per field - Gemini's function schema refuses a list of types (2026-10-01). */
   const type = criterion.type === 'number' ? 'number' : criterion.type === 'integer' ? 'integer' : criterion.type === 'boolean' ? 'boolean' : 'string'
-  const said = [criterion.description, criterion.type === 'date' ? 'YYYY-MM-DD' : undefined, criterion.type === 'enum' ? `one of: ${criterion.values!.join(', ')}` : undefined]
+  const said = [criterion.description, criterion.type === 'date' ? 'YYYY-MM-DD' : criterion.format === 'month' ? 'YYYY-MM' : undefined, criterion.type === 'enum' ? `one of: ${criterion.values!.join(', ')}` : undefined]
     .filter(Boolean)
     .join('. ')
+  if (criterion.many) return { type: 'array', items: { type }, ...(said ? { description: `${said} - one or more` } : {}) }
   return { type, ...(said ? { description: said } : {}) }
 }
 

package/test/assistant-dock.test.ts

@@ -161,7 +161,9 @@ describe('what twin needed of the dock', () => {
   it('a question with no conversation to go to is said now, never sent later; a draft waits', () => {
     assert.match(dock, /if \(waiting\.ask\) notify\(/)
     assert.match(dock, /else holdAssistantAsk\(waiting\)/)
-    assert.match(dock, /if \(this\.anchor && !isAnchor\(this\.anchor\)\) void this\.takeAsk\(\)/)
+    /* Taken when the opening ends whatever it found - a stuck anchor is said by takeAsk at once. */
+    assert.match(dock, /this\.loading = false\s*if \(this\.anchor\) void this\.takeAsk\(\)/)
+    assert.match(dock, /if \(!isAnchor\(this\.anchor\)\) \{/)
   })
 
   it('a handler\'s note stays in the conversation after its outcome is reported', () => {
@@ -227,6 +229,15 @@ describe('a screen request', () => {
   const take = dock.slice(dock.indexOf('private async takeScreenRequest()'), dock.indexOf('\n  }\n', dock.indexOf('private async takeScreenRequest()')))
   const send = chat.slice(chat.indexOf('async sendScreenRequest('), chat.indexOf('\n  }\n', chat.indexOf('async sendScreenRequest(')))
 
+  it('★ a request that reopens this screen\'s conversation is taken once the opening is done - never while it loads', () => {
+    const opening = dock.slice(dock.indexOf('private async open(): Promise<void> {'), dock.indexOf('private target('))
+    const [body, rest] = opening.split('} finally {')
+    /* takeAsk passes while loading: called inside the opening, the request stayed waiting and was never sent. */
+    assert.doesNotMatch(body, /this\.takeAsk\(\)/)
+    assert.match(rest, /this\.loading = false\s*if \(this\.anchor\) void this\.takeAsk\(\)/)
+    assert.match(dock, /private async takeAsk\(\) \{\s*if \(this\.loading \|\| !this\.anchor\) return/)
+  })
+
   it('goes its own way - a request carrying a selection is a screen request', () => {
     assert.match(dock, /if \(peekAssistantAsk\(\)\?\.selection\) return this\.takeScreenRequest\(\)/)
   })

package/test/assistant-session-manager.test.ts

@@ -9,7 +9,7 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { sessionActions } from '../client/utils/assistant-session-actions.ts'
+import { bulkActions, sessionActions } from '../client/utils/assistant-session-actions.ts'
 
 const read = (file: string) => readFileSync(join(__dirname, file), 'utf8')
 const manager = read('../client/components/assistant-session-manager.ts')
@@ -111,6 +111,58 @@ describe('opening and starting stay the host\'s', () => {
   })
 })
 
+describe('many at once, suggestions, archive and bringing back (shared dock §2-7, 2026-10-25)', () => {
+  it('★ the picked rows are each done by their own hints: delete mine, leave the ones I am only in, hide any', () => {
+    const can = bulkActions([
+      { id: 'mine', mine: true, owner: true, participant: true },
+      { id: 'member', participant: true },
+      { id: 'seen', participant: false },
+      { id: 'hidden', participant: true, hidden: true }
+    ])
+    assert.deepEqual(can.remove, ['mine'])
+    assert.deepEqual(can.leave, ['member', 'hidden'])
+    assert.deepEqual(can.hide, ['mine', 'member', 'seen'])
+  })
+
+  it('the list, the deleted ones and bringing back go through the framework doors', () => {
+    for (const door of ['archivedSessionCount', 'cleanupSessionCount', 'aiSessionKeeping', 'deletedAISessions', 'restoreAISession', 'includeArchived', 'cleanupOnly']) {
+      assert.match(admin, new RegExp(door), door)
+    }
+  })
+
+  it('★ deleting many asks once and says how long they can come back; hiding many does not ask', () => {
+    assert.match(manager, /private async askRemoveMany\(ids: string\[\]\) \{\s*const ok = await this\.ask\(/)
+    assert.match(manager, /confirm-remove-many[^\n]*\$\{this\.keptFor\(\)\}/)
+    assert.match(manager, /confirm-remove'[^\n]*\$\{this\.keptFor\(\)\}/)
+    assert.match(manager, /private hideMany\(ids: string\[\]\) \{\s*void this\.runMany\(/)
+  })
+
+  it('★ each success is told to the host like a row\'s own change, each refusal said by name', () => {
+    assert.match(manager, /if \(await run\(id\)\) \{\s*count\+\+\s*this\.emit\('assistant-session-changed', \{ sessionId: id, change \}\)/)
+    assert.match(manager, /some-refused/)
+  })
+
+  it('★ the suggestions arrive picked; the archived wait for their view', () => {
+    assert.match(manager, /this\.pickAllOnRead = view === 'cleanup'/)
+    assert.match(manager, /if \(this\.pickAllOnRead\) \{\s*this\.pickAllOnRead = false\s*this\.picked = listed/)
+    assert.match(manager, /includeArchived: this\.view === 'archived',\s*cleanupOnly: this\.view === 'cleanup'/)
+  })
+
+  it('the box picks from the space around it too, so a press beside it does not open the conversation', () => {
+    assert.equal((manager.match(/<label class="pick-area"><input type="checkbox" class="pick"/g) ?? []).length, 2)
+  })
+
+  it('the deleted view shows only what applies to it, and its search narrows by name', () => {
+    assert.match(manager, /\$\{this\.view === 'deleted' \? nothing : html`<select aria-label=\$\{t\('filter-whose'/)
+    assert.match(manager, /\.filter\(one => !word \|\| \(one\.name \?\? ''\)\.toLowerCase\(\)\.includes\(word\)\)/)
+  })
+
+  it('the deleted ones come back from their own view, by the creator\'s door', () => {
+    assert.match(manager, /this\.admin\.deleted\(this\.anchorType, this\.anchorId\)/)
+    assert.match(manager, /id => this\.admin\.restore\(id\)/)
+  })
+})
+
 describe('every word is in every locale', () => {
   const keys = [...new Set([...manager.matchAll(/\bt\('([a-z-]+)'/g)].map(match => `ai-assistant.session.${match[1]}`))]
 

package/test/open-doors.test.ts

@@ -150,11 +150,13 @@ describe('what the walk itself has to be true for', () => {
      *             agents and their usage, design/ai/agent-settings.md), declared.
      * 2026-10-24: 41 — mayInviteToAISession · inviteToAISession · removeFromAISession · leaveAISession · sayTyping declared, chatTyping open (a
      *             group conversation and its typing line, ADR-0073 decision 3).
+     * 2026-10-25: 46 — archivedSessionCount · cleanupSessionCount · aiSessionKeeping · deletedAISessions · restoreAISession
+     *             (archive, suggestions to clear and bringing a deleted one back, shared dock §2-7), declared.
      */
     const all = fieldsOf('Query').length + fieldsOf('Mutation').length + fieldsOf('Subscription').length
     const open = openFields('Query').length + openFields('Mutation').length + openFields('Subscription').length
 
-    expect(all).toBe(41)
+    expect(all).toBe(46)
     expect(open).toBe(3)
   })
 })

package/translations/en.json

@@ -146,7 +146,7 @@
   "ai-assistant.session.unhide": "Show in my list",
   "ai-assistant.session.remove": "Delete",
   "ai-assistant.session.cancel": "Cancel",
-  "ai-assistant.session.confirm-remove": "Delete \"{name}\"? It disappears for every participant and cannot be brought back.",
+  "ai-assistant.session.confirm-remove": "Delete \"{name}\"? It disappears for every participant.",
   "ai-assistant.session.confirm-open": "Make \"{name}\" public? Everyone in this domain will be able to read what is already written.",
   "ai-assistant.session.rename-refused": "this conversation could not be renamed.",
   "ai-assistant.session.hide-refused": "this conversation could not be hidden.",
@@ -249,7 +249,10 @@
   "ai-assistant.read.flow": "in or out",
   "ai-assistant.read.missing": "missing",
   "ai-assistant.read.period": "month",
+  "ai-assistant.read.period-from": "first month",
+  "ai-assistant.read.period-to": "last month",
   "ai-assistant.read.status": "status",
+  "ai-assistant.read.status-not": "status left out",
   "ai-assistant.read.min-amount": "minimum amount",
   "ai-assistant.read.max-amount": "maximum amount",
   "ai-assistant.read.text": "search words",
@@ -420,6 +423,39 @@
   "ai-assistant.session.confirm-leave": "Leave \"{name}\"? You will not read it again unless its owner brings you back.",
   "ai-assistant.session.leave-refused": "you could not leave this conversation.",
   "ai-assistant.session.audience-group": "Invited people",
+  "ai-assistant.session.archived": "Archived",
+  "ai-assistant.session.archived-count": "{count} archived - no activity for {days} days",
+  "ai-assistant.session.cleanup-empty": "Nothing of yours to clear here.",
+  "ai-assistant.session.cleanup-suggest": "{count} of yours look ready to clear - see them",
+  "ai-assistant.session.confirm-leave-many": "Leave {count} conversations? They stop coming to your list, and a group or private one is read again only when its owner brings you back.",
+  "ai-assistant.session.confirm-remove-many": "Delete {count} conversations? They disappear for every participant.",
+  "ai-assistant.session.deleted-empty": "Nothing you deleted here is kept.",
+  "ai-assistant.session.deleted-on": "Deleted {date}",
+  "ai-assistant.session.filter-view": "Show",
+  "ai-assistant.session.hidden-many": "{count} hidden from your list.",
+  "ai-assistant.session.hide-many": "Hide {count}",
+  "ai-assistant.session.kept": "You can bring it back from Deleted.",
+  "ai-assistant.session.kept-for": "You can bring it back from Deleted for {days} days.",
+  "ai-assistant.session.leave-many": "Leave {count}",
+  "ai-assistant.session.left-many": "Left {count}.",
+  "ai-assistant.session.pick": "Pick {name}",
+  "ai-assistant.session.pick-all": "Pick all",
+  "ai-assistant.session.picked": "{count} picked",
+  "ai-assistant.session.purges-on": "emptied {date}",
+  "ai-assistant.session.reason-empty": "Never asked anything",
+  "ai-assistant.session.reason-inactive": "No activity for {days} days",
+  "ai-assistant.session.remove-many": "Delete {count}",
+  "ai-assistant.session.removed-many": "{count} deleted.",
+  "ai-assistant.session.restore": "Bring back",
+  "ai-assistant.session.restore-many": "Bring back {count}",
+  "ai-assistant.session.restored": "\"{name}\" is back.",
+  "ai-assistant.session.restored-many": "{count} brought back.",
+  "ai-assistant.session.some-refused": "Not done for {count}: {names}",
+  "ai-assistant.session.unpick": "Clear the pick",
+  "ai-assistant.session.view-archived": "Including archived",
+  "ai-assistant.session.view-cleanup": "Suggested to clear",
+  "ai-assistant.session.view-deleted": "Deleted",
+  "ai-assistant.session.view-list": "Active",
   "ai-assistant.text.invite-title": "Conversation invite",
   "ai-assistant.text.invite-body-named": "{who} brought you into the conversation \"{name}\".",
   "ai-assistant.text.invite-body": "{who} brought you into a conversation.",