@things-factory/ai-assistant 10.1.79 → 10.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.79",
+  "version": "10.1.87",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -33,7 +33,7 @@
     "@operato/popup": "^10.16.0",
     "@operato/shell": "^10.0.0",
     "@operato/styles": "^10.0.0",
-    "@things-factory/ai-client-base": "^10.1.53",
+    "@things-factory/ai-client-base": "^10.1.81",
     "@things-factory/apptool-base": "^10.1.79",
     "@things-factory/attachment-base": "^10.1.79",
     "@things-factory/auth-base": "^10.1.79",
@@ -51,5 +51,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "94cde9ba17dfdddb0a16139b71e5a7e370977e4a"
+  "gitHead": "dc552c2a7b7f97e3377a26c378ee15d3a1de612a"
 }

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

@@ -521,6 +521,7 @@ export class AssistantChatResolver {
          */
         doors: answerDoors,
         toolUsages: result.loop.toolUsages?.length ? JSON.stringify(result.loop.toolUsages) : undefined,
+        proposals: result.loop.proposals?.length ? JSON.stringify(result.loop.proposals) : undefined,
         groundingWarnings: result.groundingWarnings?.length ? JSON.stringify(result.groundingWarnings) : undefined,
         creator: user,
         updater: user,

package/server/service/chat-message/chat-message.ts

@@ -151,6 +151,38 @@ export class ChatMessage {
     }
   }
 
+  /**
+   * The proposals this answer made - JSON-stringified, like `toolUsages` (ADR-0097 Q-D4 ④).
+   *
+   * A card lived only in the mutation's answer, so a refresh took it away, and with it the one place the
+   * person could see that a proposal was requested and never answered. Stored, the card comes back with
+   * its state read from the conversation's rows. Cleared with the body when the row is redacted
+   * (`message-doors.ts` VALUE_CARRYING) - a proposal carries the same values as the answer.
+   */
+  @Column({
+    type:
+      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'longtext'
+        : DATABASE_TYPE == 'oracle'
+          ? 'clob'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'text',
+    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined,
+    nullable: true
+  })
+  proposals?: string
+
+  @Field(() => GraphQLJSON, { nullable: true, description: 'Proposals this answer made - the cards the panel draws. Only on assistant messages.' })
+  get proposalsJson(): any {
+    if (!this.proposals) return null
+    try {
+      return JSON.parse(this.proposals)
+    } catch {
+      return null
+    }
+  }
+
   /**
    * 접지 경고 — 이 답이 언급했으나 근거(프롬프트·보드 문맥·이력·도구 결과)에 없던 식별자 목록.
    *

package/server/service/chat-message/proposal-outcome.test.ts

@@ -10,8 +10,8 @@
  * root and move every emitted path (`dist-client/client/…`). The server build excludes tests, so
  * reaching the other way costs nothing.
  */
-import { formatProposalOutcomeLine, PROPOSAL_VERDICTS } from './proposal-outcome'
-import { parseProposalOutcomeLine } from '../../../client/components/proposal-outcome-line'
+import { formatProposalOutcomeLine, formatProposalRequestedLine, proposalAlreadyTaken, PROPOSAL_VERDICTS } from './proposal-outcome'
+import { parseProposalOutcomeLine, parseProposalRequestLine, proposalCardState } from '../../../client/components/proposal-outcome-line'
 
 const key = 'proposeSceneEdit|{"kind":"scene-edit"}'
 
@@ -46,3 +46,54 @@ it('a key containing colons and spaces still parses', () => {
 
   expect(parseProposalOutcomeLine(line)?.key).toBe(awkward)
 })
+
+/*
+ * ADR-0097 Q-D4 ④ — a proposal is requested once, and a lost answer never becomes a second application.
+ */
+describe('requested', () => {
+  const uuid = '3f1c2a90-3b4d-4e5f-8a6b-7c8d9e0f1a2b'
+
+  it('★ the requested line round-trips, and neither line is read as the other', () => {
+    const requested = formatProposalRequestedLine(uuid)
+    expect(parseProposalRequestLine(requested)).toBe(uuid)
+    expect(parseProposalOutcomeLine(requested)).toBeUndefined()
+    expect(parseProposalRequestLine(formatProposalOutcomeLine(uuid, { verdict: 'accepted' }))).toBeUndefined()
+  })
+
+  it('★ a proposal is taken once it is requested or answered — then the host is not asked again', () => {
+    expect(proposalAlreadyTaken(uuid, [])).toBe(false)
+    expect(proposalAlreadyTaken(uuid, ['User directly edited the board', null])).toBe(false)
+    expect(proposalAlreadyTaken(uuid, [formatProposalRequestedLine(uuid)])).toBe(true)
+    for (const verdict of PROPOSAL_VERDICTS) {
+      expect(proposalAlreadyTaken(uuid, [formatProposalOutcomeLine(uuid, { verdict, errorCode: 'x', applied: 1, missed: 1 })])).toBe(true)
+    }
+  })
+
+  it('another proposal is not taken by this one, even when one key begins with the other', () => {
+    expect(proposalAlreadyTaken('a', [formatProposalRequestedLine('a: b')])).toBe(false)
+    expect(proposalAlreadyTaken('a', [formatProposalOutcomeLine('a: b', { verdict: 'accepted' })])).toBe(false)
+    expect(proposalAlreadyTaken(uuid, [formatProposalRequestedLine('other')])).toBe(false)
+  })
+})
+
+describe('the card state', () => {
+  const none = { outcomes: new Map(), requested: new Set<string>(), sentHere: false }
+
+  it('nothing taken — the run button', () => {
+    expect(proposalCardState('k', none).state).toBe('ready')
+  })
+
+  it('this page asked and no answer came — applying, however long it has been', () => {
+    expect(proposalCardState('k', { ...none, requested: new Set(['k']), sentHere: true }).state).toBe('applying')
+  })
+
+  it('★ requested before a refresh or elsewhere, with no answer — "check result", never "run"', () => {
+    expect(proposalCardState('k', { ...none, requested: new Set(['k']) }).state).toBe('unconfirmed')
+  })
+
+  it('★ an answer wins over everything', () => {
+    const outcome = parseProposalOutcomeLine(formatProposalOutcomeLine('k', { verdict: 'refused', errorCode: 'stale' }))!
+    const state = proposalCardState('k', { outcomes: new Map([['k', outcome]]), requested: new Set(['k']), sentHere: true })
+    expect(state).toEqual({ state: 'answered', outcome })
+  })
+})

package/server/service/chat-message/proposal-outcome.ts

@@ -40,3 +40,36 @@ export function formatProposalOutcomeLine(key: string, outcome: ProposalOutcome)
       : ''
   return `${PROPOSAL_OUTCOME_PREFIX}${key}: ${outcome.verdict}${reason}${counted}`
 }
+
+/*
+ * "Requested" — written before the host is asked to run a proposal (ADR-0097 Q-D4 ④).
+ *
+ * The card used to remember that it was pressed in the page's memory only. After a refresh a
+ * proposal whose outcome never came back had its button again, and pressing it asked the host to
+ * apply it a second time. The request is now a row, like the outcome, so every reader sees it: the
+ * card after a refresh, another window, and the model ("requested, no answer yet").
+ *
+ * It is not a verdict — nothing happened yet. It only says the host was asked.
+ */
+export const PROPOSAL_REQUESTED = 'requested'
+
+/** `proposal <key>: requested` */
+export function formatProposalRequestedLine(key: string): string {
+  return `${PROPOSAL_OUTCOME_PREFIX}${key}: ${PROPOSAL_REQUESTED}`
+}
+
+/**
+ * Whether this proposal was already taken in this conversation — requested, or answered.
+ * The caller passes the conversation's system lines; the answer is the rule, kept testable.
+ */
+export function proposalAlreadyTaken(key: string, systemLines: readonly (string | null | undefined)[]): boolean {
+  const requested = formatProposalRequestedLine(key)
+  const answered = `${PROPOSAL_OUTCOME_PREFIX}${key}: `
+  return systemLines.some(line => {
+    const text = (line ?? '').trim()
+    if (text === requested) return true
+    if (!text.startsWith(answered)) return false
+    const rest = text.slice(answered.length)
+    return PROPOSAL_VERDICTS.some(verdict => rest === verdict || rest.startsWith(`${verdict} `))
+  })
+}

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

@@ -146,12 +146,12 @@ export class ChatSession {
    *   `open`     도메인 안이면 누구나 들어와 읽고 말한다. 초대 절차는 없다.
    *   `private`  참여자만 읽는다.
    *
-   * 앵커가 있는 세션(space · board · station)은 공유된 무엇을 놓고 하는 이야기이므로 `open` 으로
-   * 시작한다. 앵커가 없는 세션과 **옮겨 적어 만든 세션**은 `private` 으로 시작한다 — 가벼운 질문을
-   * 승격하면서 앞선 대화가 새 세션에 옮겨 적히는데(`appendSessionTurns`), 그것이 공개로 태어나면
-   * 사적으로 오간 원문이 소급해서 공개된다.
+   * 새 세션은 **모두** `private` 으로 시작한다(2026-09-30 — `initialVisibility`). 앵커는 무엇에 대한
+   * 이야기인지를 말할 뿐 누구에게 보이는지를 정하지 않는다. 칸의 기본값 `open` 은 칸이 서기 전의 옛 행을
+   * 그날까지의 규칙대로 읽기 위한 것이고, 새 행은 늘 값을 적는다.
    *
-   * owner 가 양방향으로 바꿀 수 있다. 공개로 바꾸기 전에 화면이 한 줄을 먼저 보인다.
+   * owner 가 양방향으로 바꿀 수 있다. 공개로 바꾸기 전에 화면이 한 줄을 먼저 보이고, 공개 대화는 도크가
+   * 다르게 그린다.
    *
    * open 이어도 답 행의 문 판정(ADR-0073 판정 1)은 그대로다 — 방에 들어온 것과 값을 읽는 것은 다르다.
    */

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

@@ -179,6 +179,13 @@ export function searchInbox(entries: InboxEntry[], search?: string): InboxEntry[
   )
 }
 
+/** Only readable user/assistant prose participates; never match a redaction notice or execution log. */
+export function searchReadableMessages(rows: readonly { sessionId?: string; content?: string; role?: string; redacted?: boolean }[], search: string): Set<string> {
+  const q = search.trim().toLowerCase()
+  return new Set(rows.filter(row => q && !row.redacted && (row.role === 'user' || row.role === 'assistant') && row.content?.toLowerCase().includes(q))
+    .map(row => row.sessionId).filter((id): id is string => !!id))
+}
+
 /** 한 번에 훑는 세션 상한 — 이보다 많으면 잘렸다고 알린다(정직). */
 export const INBOX_SCAN_CAP = 500
 

package/server/service/chat-session/session-visibility.test.ts

@@ -6,10 +6,10 @@
 import { initialVisibility, mayReadSession } from './session-visibility'
 
 describe('session visibility', () => {
-  it('앵커가 있는 대화는 공개로 시작한다 — 공유된 대상을 놓고 하는 이야기다', () => {
-    expect(initialVisibility({ anchorType: 'space' })).toBe('open')
-    expect(initialVisibility({ anchorType: 'board' })).toBe('open')
-    expect(initialVisibility({ anchorType: 'station' })).toBe('open')
+  it('★ 앵커가 있어도 비공개로 시작한다 — 앵커는 무엇에 대한 이야기인지이지 누구에게 보이는지가 아니다', () => {
+    for (const anchorType of ['space', 'board', 'station', 'application', 'domain', 'subject', 'figure', 'instance']) {
+      expect(initialVisibility({ anchorType })).toBe('private')
+    }
   })
 
   it('★ 옮겨 적어 만든 대화는 비공개로 시작한다 — 원문이 소급 공개되지 않는다', () => {
@@ -46,8 +46,8 @@ describe("'none' is not an anchor", () => {
     expect(initialVisibility({ anchorType: 'none' })).toBe('private')
   })
 
-  it('대상이 있는 대화는 그대로 공개다', () => {
-    expect(initialVisibility({ anchorType: 'space' })).toBe('open')
+  it('대상이 있는 대화도 비공개다', () => {
+    expect(initialVisibility({ anchorType: 'space' })).toBe('private')
   })
 })
 

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

@@ -9,23 +9,17 @@ export type SessionVisibility = 'open' | 'private'
 export const SESSION_VISIBILITIES: readonly SessionVisibility[] = ['open', 'private']
 
 /**
- * 이렇게 만들어진 세션은 무엇으로 시작하나.
+ * 이렇게 만들어진 세션은 무엇으로 시작하나 — **언제나 비공개.**
  *
- * 앵커가 있으면 공유된 대상을 놓고 하는 이야기다 — 공개. 앵커가 없거나 앞선 대화를 옮겨 적어 만든
- * 것이면 비공개. `copyOf` 가 있다는 것은 다른 대화의 원문이 이 안에 들어왔다는 뜻이고, 그 원문은
- * 자기가 있던 자리의 규칙으로 쓰였다.
+ * ── 앵커가 있으면 공개로 태어나던 것을 거둔 이유 (2026-09-30, 제품 오너) ──
+ * operato-office 의 대화는 앱 행(`application`)에 매달린다. 그래서 원장 · 급여를 묻는 경영자의 질문이 도메인
+ * 안 모든 직원에게 열린 방으로 태어났다. 목록은 그것을 「사업장 공개」 한 줄로만 말해서 공개와 비공개가 한눈에
+ * 갈리지 않았다. 앵커는 「무엇에 대한 이야기인가」이지 「누구에게 보이나」가 아니다.
+ *
+ * 공개는 owner 가 고른다(`setSessionVisibility`) — 화면이 여는 순간 되묻고, 공개 대화는 도크가 다르게 그린다.
  */
-export function initialVisibility(session: { anchorType?: string | null; copyOf?: string | null }): SessionVisibility {
-  if (session.copyOf) return 'private'
-
-  /*
-   * `'none'` 은 **앵커가 아니다.** 저장되는 앵커 종류 목록에 그 글자가 들어 있어서(`session-anchor.ts`
-   * — 대상이 없다는 것도 행에 적어야 하므로), 「값이 있으면 앵커가 있다」로 읽으면 대상 없는 개인 질문이
-   * 공개 방으로 태어난다. ADR-0073 결정 2 가 그것을 `private` 로 못박았다 — 「앵커 없는 세션(`twin.none`
-   * 같은 개인 질문)」.
-   */
-  const anchored = !!session.anchorType && session.anchorType !== 'none'
-  return anchored ? 'open' : 'private'
+export function initialVisibility(_session: { anchorType?: string | null; copyOf?: string | null } = {}): SessionVisibility {
+  return 'private'
 }
 
 /** 이 사람이 이 대화를 읽을 수 있나. open 이면 도메인 안 누구나, private 이면 참여자만. */

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

@@ -10,11 +10,11 @@ import { User } from '@things-factory/auth-base'
 import { buildDomainUsersQueryBuilder } from '@things-factory/auth-base/dist-server/utils/get-domain-users.js'
 
 import { getRepository } from '@things-factory/shell'
-import { In } from 'typeorm'
+import { In, Like } 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, INBOX_SCAN_CAP, type InboxFilter } from './chat-session/session-inbox.js'
+import { buildInbox, applyHidden, activityPatch, 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'
@@ -51,7 +51,14 @@ async function writeGate(session: any, context: any, tx?: any): Promise<void> {
     t: (key, options) => (context.t ? context.t(key, options) : String(options?.defaultValue ?? key))
   })
 }
-import { formatProposalOutcomeLine, PROPOSAL_VERDICTS, type ProposalOutcome } from './chat-message/proposal-outcome.js'
+import {
+  formatProposalOutcomeLine,
+  formatProposalRequestedLine,
+  proposalAlreadyTaken,
+  PROPOSAL_OUTCOME_PREFIX,
+  PROPOSAL_VERDICTS,
+  type ProposalOutcome
+} from './chat-message/proposal-outcome.js'
 import { publishSessionActivity } from './chat-session/session-activity-publish.js'
 import { ChatMessage } from './chat-message/chat-message.js'
 import { ChatSessionParticipant } from './chat-session-participant/chat-session-participant.js'
@@ -262,7 +269,21 @@ export class ChatSessionResolver {
     const all = await this._inboxEntries(anchorType, anchorId, context)
     let entries = opts.showHidden ? all : all.filter(e => !e.hidden)
     entries = filterInbox(entries as any, opts) as any
-    return searchInbox(entries as any, opts.search) as any
+    if (!opts.search?.trim() || !entries.length) return entries
+    // Search only readable rooms, then pass their messages through the SAME reader gate.
+    // A match in a redacted answer must not reveal even that a conversation contains it.
+    const messages = await getRepository(ChatMessage).find({
+      where: { session: { id: In(entries.map(entry => entry.id)) } },
+      order: { createdAt: 'DESC', id: 'DESC' },
+      take: 2001
+    })
+    if (messages.length > 2000) {
+      throw new Error(context.t('ai-assistant.session.search-too-broad', { defaultValue: 'Too many messages to search here. Narrow the conversation filters and try again.' }))
+    }
+    const readable = await readerGate(context)(messages)
+    const matched = searchReadableMessages(readable, opts.search)
+    const names = new Set(searchInbox(entries as any, opts.search).map(entry => entry.id))
+    return entries.filter(entry => names.has(entry.id) || matched.has(entry.id))
   }
 
   /**
@@ -637,7 +658,7 @@ export class ChatSessionResolver {
     const session = await repo.save({
       domain,
       ...anchorColumns(anchorType, anchorId),
-      /* 앵커가 있는 대화는 공개로 태어난다 — ADR-0073 판정 2. */
+      /* 새 대화는 비공개로 태어난다 — 공개는 owner 가 고른다(ADR-0073 결정 2, 2026-09-30 고침). */
       visibility: initialVisibility({ anchorType }),
       creator: user,
       updater: user
@@ -663,19 +684,14 @@ export class ChatSessionResolver {
   async createAISession(
     @Arg('anchorType') anchorType: string,
     @Arg('anchorId') anchorId: string,
-    @Arg('name', { nullable: true, description: 'Optional name. Defaults to a generated one, numbered within the anchor.' }) name: string | undefined,
+    @Arg('name', { nullable: true, description: 'Optional name. If omitted, the first question names the conversation.' }) name: string | undefined,
     @Ctx() context: ResolverContext
   ): Promise<ChatSession> {
     const { domain, user, tx } = context.state
     const repo = getRepository(ChatSession, tx)
 
-    // 이름 미지정 시 자동 생성 — **같은 앵커**의 기존 세션 수 + 1.
-    let finalName = name?.trim()
-    if (!finalName) {
-      const count = await repo.count({ where: anchorWhere(domain.id, anchorType, anchorId) })
-      /* The name is stored, so it is written in the language of whoever created it (context.t), and read back as is. */
-      finalName = context.t('ai-assistant.session.default-name', { n: count + 1, defaultValue: 'conversation {n}' })
-    }
+    // Do not prefill a numbered name: that prevents the first question from naming it.
+    const finalName = name?.trim() || null
 
     const session = await repo.save({
       domain,
@@ -767,6 +783,49 @@ export class ChatSessionResolver {
     return true
   }
 
+  @Directive('@transaction')
+  @Mutation(() => Boolean, {
+    description:
+      "Ask before running a proposal: true when this conversation has not taken it yet, and the request is recorded as a system row; false when it was already requested or answered - then the host must not be asked again. The card reads its state from these rows, so a refreshed panel or another window does not offer the same proposal twice (ADR-0097)."
+  })
+  @Directive('@privilege(category: "ai-assistant", privilege: "mutation", domainOwnerGranted: true)')
+  async requestProposal(
+    @Arg('sessionId') sessionId: string,
+    @Arg('proposalKey') proposalKey: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, user, tx } = context.state
+    const session = await getRepository(ChatSession, tx).findOneBy({ id: sessionId, domain: { id: domain.id } })
+    if (!session) throw new Error(`ChatSession ${sessionId} not found`)
+    await writeGate(session, context, tx)
+
+    const key = (proposalKey ?? '').trim()
+    if (!key) return false
+
+    /* Only this conversation's proposal lines - a conversation is bounded, and the rule reads them all. */
+    const lines = await getRepository(ChatMessage, tx).find({
+      select: ['content'] as any,
+      where: { session: { id: session.id } as any, role: 'system', content: Like(`${PROPOSAL_OUTCOME_PREFIX}%`) } as any
+    })
+    if (proposalAlreadyTaken(key, lines.map(line => (line as any).content))) return false
+
+    const previousLast = await getRepository(ChatMessage, tx).findOne({
+      where: { session: { id: session.id } as any },
+      order: { createdAt: 'DESC' }
+    })
+    const row = await getRepository(ChatMessage, tx).save({
+      session: { id: session.id } as any,
+      role: 'system',
+      content: formatProposalRequestedLine(key),
+      creator: user,
+      updater: user,
+      parentMessage: previousLast ? ({ id: previousLast.id } as any) : undefined
+    } as any)
+
+    publishChatMessage({ domainId: domain.id, sessionId: session.id, message: row })
+    return true
+  }
+
   /**
    * Stores files with a conversation before the turn that carries them (design/ai/shared-dock.md §9).
    * Passes the write gate - a private conversation takes files from its people only - and the mode's

package/server/service/session-anchor.test.ts

@@ -192,7 +192,7 @@ describe('the subject anchor', () => {
     expect(anchorColumns('application', 'operato-figure').anchorId).toBe('operato-figure')
   })
 
-  it('★ a subject conversation is born open — an anchored conversation is about a shared thing (ADR-0073 decision 2)', () => {
-    expect(initialVisibility({ anchorType: 'subject' })).toBe('open')
+  it('★ a subject conversation is born private — opening it is the owner\'s choice (ADR-0073 decision 2, 2026-09-30)', () => {
+    expect(initialVisibility({ anchorType: 'subject' })).toBe('private')
   })
 })

package/test/assistant-dock.test.ts

@@ -24,6 +24,11 @@ describe('no empty panel', () => {
   it('an unreadable capability offers a retry', () => {
     assert.match(dock, /this\.capability === 'unknown'\s*\?\s*html`<div><button class="sbtn" @click=\$\{\(\) => this\.open\(\)\}>/)
   })
+
+  it('a surface can give the person one concrete next route', () => {
+    assert.match(dock, /surface\?\.nextStep \? html`<div class="next-step" role="status">/)
+    assert.match(dock, /<a href=\$\{surface\.nextStep\.href\}>\$\{surface\.nextStep\.label\(\)\}/)
+  })
 })
 
 describe('the dock opens on every screen', () => {
@@ -52,7 +57,7 @@ describe('every request the chat makes is taken', () => {
 
 describe('every proposal ends in one reported outcome', () => {
   it('the dock reports whatever the handler returned', () => {
-    assert.match(dock, /const outcome = await runProposal\(proposal, this\.proposalContext\(sessionId\)\)[\s\S]*await this\.report\(sessionId, proposalKey, outcome\)/)
+    assert.match(dock, /const outcome: ProposalOutcome =[\s\S]*await runProposal\(proposal, this\.proposalContext\(sessionId\)\)[\s\S]*await this\.report\(sessionId, proposalKey, outcome\)/)
   })
 
   it('a kind nobody handles is unavailable, by name', async () => {
@@ -89,7 +94,7 @@ describe('sessions', () => {
 
 describe('the screen is checked at send time', () => {
   it('a send after the screen moved on is refused', () => {
-    assert.match(dock, /if \(openedFor !== this\.scopeKey\(currentAssistantSurface\(\) \?\? surface\)\) throw new Error/)
+    assert.match(dock, /if \(openedFor !== this\.scopeKey\(currentAssistantSurface\(\)\) \|\| this\.openedIdentity !== this\.identityKey\(\)\) throw new Error/)
   })
 
   it('the draft is read at send time, never cached', () => {
@@ -125,7 +130,7 @@ describe('attachments in the chat follow the mode', () => {
 
 describe('what twin needed of the dock', () => {
   it('a surface that says its words changed repaints the header without reopening the conversation', () => {
-    assert.match(dock, /next === this\.surface && this\.scopeKey\(next\) === this\.openedFor\) \{\s*this\.requestUpdate\(\)\s*return/)
+    assert.match(dock, /transition === 'refresh'\) \{\s*this\.surface = next\s*this\.screenChanged = false\s*this\.requestUpdate\(\)\s*return/)
   })
 
   it('a question with no conversation to go to is said now, never sent later; a draft waits', () => {

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

@@ -10,7 +10,7 @@ test('toolbar emits domain-neutral intent and never calls persistence APIs', ()
 })
 test('busy/error/temporary states and accessible controls are explicit', () => {
   assert.match(toolbar, /this\.disabled \|\| this\.loading \|\| !!this\.error/)
-  assert.match(toolbar, /this\.temporary \? nothing/)
+  assert.match(toolbar, /this\.temporary \|\| this\.singleConversation \? nothing/)
   assert.match(toolbar, /aria-label=/)
   assert.match(toolbar, /role="tablist"/)
   assert.match(toolbar, /role="tab"/)
@@ -18,6 +18,12 @@ test('busy/error/temporary states and accessible controls are explicit', () => {
   assert.match(toolbar, /role="alert"/)
   assert.match(toolbar, /role="status"/)
 })
+test('shared dock has one list entry, not tabs and a second history link', () => {
+  assert.match(toolbar, /this\.historyEnabled && !this\.singleConversation/)
+  const dock = read('../client/components/assistant-dock.ts')
+  assert.match(dock, /historyEnabled\s+singleConversation/)
+  assert.match(dock, /ready && this\.showingHistory/)
+})
 test('legacy Board chat forwards shared controls through existing host events', () => {
   const chat = read('../client/components/assistant-chat.ts')
   assert.match(chat, /import '\.\/assistant-session-toolbar\.js'/)

package/test/open-doors.test.ts

@@ -141,11 +141,12 @@ describe('what the walk itself has to be true for', () => {
     /*
      * 2026-09-24: 27 root fields, 25 declared, 2 open — both streams.
      * 2026-09-25: 28 — attachToConversation (a conversation's files, shared dock §9), declared.
+     * 2026-09-28: 29 — requestProposal (a proposal is requested once, ADR-0097 Q-D4), 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(28)
+    expect(all).toBe(29)
     expect(open).toBe(2)
   })
 })

package/test/session-discovery.test.ts

@@ -0,0 +1,42 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { autoSessionName, searchReadableMessages } from '../server/service/chat-session/session-inbox.js'
+
+describe('returning to work by its subject', () => {
+  it('finds an earlier question, not just the final execution log', () => {
+    expect([...searchReadableMessages([
+      { sessionId: 'lift', role: 'user', content: '리프트 테이블을 만들어 줘' },
+      { sessionId: 'lift', role: 'system', content: 'accepted 13/13' }
+    ], '리프트')]).toEqual(['lift'])
+  })
+  it('cannot discover redacted answers or internal execution notes', () => {
+    expect([...searchReadableMessages([
+      { sessionId: 'secret', role: 'assistant', content: 'restricted value', redacted: true },
+      { sessionId: 'log', role: 'system', content: 'restricted value' },
+      { sessionId: 'public', role: 'assistant', content: 'Restricted value is unavailable' }
+    ], 'restricted')]).toEqual(['public'])
+    expect(searchReadableMessages([{ sessionId: 'a', role: 'user', content: 'hi' }], '  ').size).toBe(0)
+  })
+  it('names a new conversation from the first question', () => {
+    expect(autoSessionName('리프트 테이블을 만들어 줘. 폭은 600')).toBe('리프트 테이블을 만들어 줘')
+    const resolver = readFileSync(join(__dirname, '../server/service/chat-session-resolver.ts'), 'utf8')
+    expect(resolver).toContain("const finalName = name?.trim() || null")
+    expect(resolver).toContain('await readerGate(context)(messages)')
+    expect(resolver).toContain('take: 2001')
+  })
+})
+
+describe('discoverable conversation controls', () => {
+  const manager = readFileSync(join(__dirname, '../client/components/assistant-session-manager.ts'), 'utf8')
+  it('uses a native button to open a conversation and a visible disclosure to manage it', () => {
+    expect(manager).toContain('<button class="open-row"')
+    expect(manager).toContain('<summary aria-label=')
+    expect(manager).not.toContain('.row:hover .acts')
+  })
+  it('distinguishes filtered emptiness, supplies reset, and folds advanced filters', () => {
+    expect(manager).toContain("t('filtered-empty'")
+    expect(manager).toContain('this.resetFilters()')
+    expect(manager).toContain('?hidden=${!this.filtersOpen}')
+    expect(manager).toContain('e.stopPropagation(); this.onSearch')
+  })
+})

package/translations/en.json

@@ -1,4 +1,25 @@
 {
+  "ai-assistant.dock.wait-before-switch": "Wait for the current response before changing conversations.",
+  "ai-assistant.dock.switch-title": "Change conversation?",
+  "ai-assistant.dock.switch-draft": "Your unsent text and attachments will not move to the other conversation.",
+  "ai-assistant.dock.switch-confirm": "Discard draft and switch",
+  "ai-assistant.dock.stay": "Keep writing",
+  "ai-assistant.dock.now-about": "Conversation subject: {name}",
+  "ai-assistant.dock.ask-kept-current": "The current conversation was kept. Switch to the intended subject before asking again.",
+  "ai-assistant.dock.return-to-subject": "Return to the conversation subject before sending or applying changes.",
+  "ai-assistant.dock.screen-and-conversation": "Screen: {screen}. Conversation: {conversation}. Your conversation has been kept.",
+  "ai-assistant.dock.no-subject": "No subject",
+  "ai-assistant.dock.switch-to-screen": "Talk about this screen",
+  "ai-assistant.session.filters": "Filters",
+  "ai-assistant.session.reset-filters": "Clear search and filters",
+  "ai-assistant.session.filtered-empty": "No conversations match these filters here.",
+  "ai-assistant.session.scope-empty": "No conversations for this subject yet.",
+  "ai-assistant.session.audience-private": "Participants only",
+  "ai-assistant.session.audience-open": "Everyone in this domain",
+  "ai-assistant.session.manage": "Manage conversation",
+  "ai-assistant.session.list": "Conversations",
+  "ai-assistant.dock.conversation-scope": "Conversations · {name}",
+  "ai-assistant.session.search-too-broad": "Too many messages to search here. Narrow the conversation filters and try again.",
   "ai-assistant.session.new": "New conversation",
   "ai-assistant.session.history": "Conversation history",
   "ai-assistant.session.reset": "New conversation",
@@ -102,6 +123,10 @@
   "ai-assistant.verdict.unavailable": "could not run",
   "ai-assistant.verdict.declined": "cancelled",
   "ai-assistant.text.proposal-waiting": "sending — {seconds}s, no answer yet",
+  "ai-assistant.text.proposal-unconfirmed": "sent earlier — no answer received",
+  "ai-assistant.button.check-proposal": "check result",
+  "ai-assistant.dock.proposal-result-uncheckable": "this screen cannot check that result. open the screen where it was applied.",
+  "ai-assistant.dock.proposal-result-unknown": "the result is still unknown. it was not applied again.",
   "ai-assistant.text.proposal-applied-count": " {applied} of {total}",
   "ai-assistant.text.say-to-room-tooltip": "say this to the people here — the assistant does not answer",
   "ai-assistant.text.no-room-yet": "this conversation is not saved yet, so there is nobody else in it to talk to",
@@ -111,7 +136,7 @@
   "ai-assistant.label.conversation": "conversation",
   "ai-assistant.text.switch-conversation": "switch to {name}",
   "ai-assistant.text.session-kind-mismatch": "this conversation is {sessionKind}, and you are writing as {requested}. open the conversation you mean.",
-  "ai-assistant.session.search": "Search names and last messages",
+  "ai-assistant.session.search": "Search conversation names and messages",
   "ai-assistant.session.filter": "Which conversations",
   "ai-assistant.session.filter-all": "All",
   "ai-assistant.session.filter-mine": "Started by me",
@@ -171,5 +196,6 @@
   "ai-assistant.session.filter-open": "Public",
   "ai-assistant.session.filter-private": "Private",
   "ai-assistant.session.filter-unread": "Unread",
-  "ai-assistant.dock.ask-needs-conversation": "the question was not sent."
+  "ai-assistant.dock.ask-needs-conversation": "the question was not sent.",
+  "ai-assistant.dock.audience-open-band": "Public conversation - everyone in this domain can read and write here."
 }