@things-factory/board-ai 10.1.27 → 10.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/board-ai",
-  "version": "10.1.27",
+  "version": "10.1.29",
   "main": "dist-server/index.js",
   "browser": "dist-client/client/index.js",
   "things-factory": true,
@@ -32,12 +32,12 @@
     "@operato/i18n": "^10.0.0",
     "@operato/scene-ops": "^10.14.1",
     "@operato/styles": "^10.0.0",
-    "@things-factory/ai-assistant": "^10.1.27",
-    "@things-factory/ai-client-base": "^10.1.26",
-    "@things-factory/auth-base": "^10.1.27",
-    "@things-factory/board-import": "^10.1.27",
+    "@things-factory/ai-assistant": "^10.1.29",
+    "@things-factory/ai-client-base": "^10.1.29",
+    "@things-factory/auth-base": "^10.1.29",
+    "@things-factory/board-import": "^10.1.29",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/shell": "^10.1.27",
+    "@things-factory/shell": "^10.1.29",
     "dompurify": "^3.0.0",
     "graphql-tag": "^2.12.6",
     "lit": "^3.1.2",
@@ -47,5 +47,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "d04dc762cacf2aac8ba0b0f5d768eca365fc09da"
+  "gitHead": "e6bf9dec003fe5e794746aaeb5852b3b50478232"
 }

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

@@ -30,7 +30,10 @@ import { publishSessionActivity } from '@things-factory/ai-assistant'
 import { ChatMessage } from '@things-factory/ai-assistant'
 import { publishChatMessage } from '@things-factory/ai-assistant'
 import { ChatSessionResolver } from '@things-factory/ai-assistant'
+import { ChatSessionParticipant } from '@things-factory/ai-assistant'
+import { mayReadSession } from '@things-factory/ai-assistant'
 import { PatchEntry } from './patch-entry/patch-entry.js'
+import { mayRevertPatch } from './patch-entry/revert-permission.js'
 import { publishBoardPatch } from './patch-entry/board-patch-subscription.js'
 
 /** 중립 op 로의 위임 대상. 리졸버는 상태가 없으므로 하나면 된다. */
@@ -176,8 +179,27 @@ export class BoardSessionResolver {
     @Arg('patchId') patchId: string,
     @Ctx() context: ResolverContext
   ): Promise<boolean> {
-    const { tx } = context.state
-    await getRepository(PatchEntry, tx).update(patchId, { reverted: true })
+    const { domain, user, tx } = context.state
+
+    /* A patch id alone is not permission — see `patch-entry/revert-permission.ts`. */
+    const patch = await getRepository(PatchEntry, tx).findOne({
+      where: { id: patchId, session: { domain: { id: domain.id } } } as any,
+      relations: ['session']
+    })
+    const session: any = patch?.session
+    const isParticipant =
+      !!session && !!user?.id
+        ? !!(await getRepository(ChatSessionParticipant, tx).findOneBy({
+            session: { id: session.id },
+            user: { id: user.id }
+          } as any))
+        : false
+
+    if (!mayRevertPatch(patch ? { sessionVisibility: session?.visibility } : null, isParticipant, mayReadSession)) {
+      throw new Error(`PatchEntry ${patchId} not found`)
+    }
+
+    await getRepository(PatchEntry, tx).update(patch!.id!, { reverted: true })
     return true
   }
 }

package/server/service/mention-marker.ts

@@ -27,47 +27,15 @@ import { findMentions, type MentionPick } from './mention-resolver'
  */
 export const MENTION_MARKER_RE = /\{[a-zA-Z][a-zA-Z0-9]*:[^}\s]+\}/g
 
-/**
- * 멘션된 userId 중 *아직 참여자가 아닌* + *자기 자신이 아닌* 신규만 (C4 초대 — 차집합).
- * 순수 — 누구를 새로 참여자 등록할지 판정. (resolver 가 repo 작업과 분리해 테스트 가능.)
+/*
+ * 이 둘은 **`@things-factory/ai-assistant` 로 옮겼다**(ADR-0071 결정 1).
+ *
+ * 멘션이 사람을 불러들이는 일은 보드만의 일이 아니다 — 트윈 협의에서 `@이름` 은 아무도 부르지 않고
+ * 있었다. 규칙이 이 제품 안에 있는 한 다른 문은 그것을 쓸 수 없다. 여기서는 이름만 다시 내보내
+ * 이 패키지의 부르는 자리가 그대로 돌게 한다.
  */
-export function newParticipantUserIds(
-  mentioned: ReadonlyArray<string>,
-  existing: ReadonlyArray<string>,
-  selfUserId?: string | null
-): string[] {
-  const have = new Set(existing)
-  if (selfUserId) have.add(selfUserId)
-  const out: string[] = []
-  const seen = new Set<string>()
-  for (const id of mentioned) {
-    if (!id || have.has(id) || seen.has(id)) continue
-    seen.add(id)
-    out.push(id)
-  }
-  return out
-}
+export { extractMentionUserIds, newParticipantUserIds } from '@things-factory/ai-assistant'
 
-/**
- * 본문에서 `@user{userId:UUID}` 마커의 *userId 집합* 추출 (C4 — 초대 트리거).
- * 같은 user 중복 제거, 순서 보존(첫 등장순). 마커 없으면 빈 배열.
- * 순수 — content 만으로 "이 메시지가 누구를 멘션했나" 판정.
- */
-export function extractMentionUserIds(text: string | null | undefined): string[] {
-  if (!text) return []
-  const re = /\{userId:([^}\s]+)\}/g
-  const seen = new Set<string>()
-  const out: string[] = []
-  let m: RegExpExecArray | null
-  while ((m = re.exec(text)) !== null) {
-    const id = m[1]
-    if (!seen.has(id)) {
-      seen.add(id)
-      out.push(id)
-    }
-  }
-  return out
-}
 
 /**
  * 본문에서 모든 `{key:value}` 인라인 마커 제거. LLM 입력 / textarea 편집 / 평문 표출 등.

package/server/service/patch-entry/revert-permission.ts

@@ -0,0 +1,28 @@
+/*
+ * Who may flag a patch as reverted.
+ *
+ * `revertPatch` used to take a patch id and write — the privilege gate was the only check, so anyone
+ * holding `board-ai:mutation` in ANY tenant could flag a patch in another tenant's conversation by
+ * knowing (or guessing) its id, and a person could reach into a private conversation they are not
+ * part of (operato-twin ADR-0061 "what was left", found again by the 2026-09-18 ADR audit).
+ *
+ * The rule is the conversation's own: a patch belongs to a session, and a person may act on it only
+ * where they may read that session — the caller's tenant, and for a private session, a participant
+ * (ADR-0073 decision 2). The lookup is scoped by tenant, so a patch elsewhere simply is not found.
+ *
+ * One answer for every refusal. Telling "exists but not yours" apart from "does not exist" would
+ * confirm an id to someone who should not learn it.
+ */
+export interface FoundPatch {
+  /** `ChatSession.visibility` of the session the patch belongs to. */
+  sessionVisibility?: string | null
+}
+
+export function mayRevertPatch(
+  found: FoundPatch | null | undefined,
+  isParticipant: boolean,
+  mayReadSession: (visibility: string | null | undefined, isParticipant: boolean) => boolean
+): boolean {
+  if (!found) return false
+  return mayReadSession(found.sessionVisibility, isParticipant)
+}

package/test/revert-permission.test.ts

@@ -0,0 +1,41 @@
+/*
+ * revertPatch — a patch id alone is not permission.
+ *
+ * The resolver cannot be imported here (type-graphql decorators), so the judgement lives in a pure
+ * function and the resolver only feeds it. What this file pins is the rule; that the resolver asks
+ * it, and asks with a tenant-scoped lookup, is pinned by reading its source below.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { mayRevertPatch } from '../server/service/patch-entry/revert-permission.ts'
+import { mayReadSession } from '../../ai-assistant/server/service/chat-session/session-visibility.ts'
+
+test('a patch that the tenant-scoped lookup did not find is refused', () => {
+  assert.equal(mayRevertPatch(null, true, mayReadSession), false)
+  assert.equal(mayRevertPatch(undefined, false, mayReadSession), false)
+})
+
+test('an open conversation lets anyone in the tenant flag its patch', () => {
+  assert.equal(mayRevertPatch({ sessionVisibility: 'open' }, false, mayReadSession), true)
+})
+
+test('a private conversation lets only a participant', () => {
+  assert.equal(mayRevertPatch({ sessionVisibility: 'private' }, false, mayReadSession), false)
+  assert.equal(mayRevertPatch({ sessionVisibility: 'private' }, true, mayReadSession), true)
+})
+
+test('a session written before the column existed reads as open, the same as everywhere else', () => {
+  assert.equal(mayRevertPatch({ sessionVisibility: null }, false, mayReadSession), true)
+})
+
+const RESOLVER = readFileSync(join(import.meta.dirname, '../server/service/board-session-resolver.ts'), 'utf-8')
+const body = RESOLVER.slice(RESOLVER.indexOf('async revertPatch('))
+
+test('the door looks the patch up inside the caller\'s tenant, and asks the rule before writing', () => {
+  assert.ok(/domain:\s*\{\s*id:\s*domain\.id\s*\}/.test(body), 'the lookup is not scoped by domain')
+  assert.ok(body.indexOf('mayRevertPatch(') > -1, 'the door does not ask the rule')
+  assert.ok(body.indexOf('mayRevertPatch(') < body.indexOf('.update('), 'the door writes before it asks')
+})

package/test/fold-history-window.test.ts

@@ -1,158 +0,0 @@
-/*
- * ★ 요약 접기는 **필요한 만큼만 읽는다** — 그러면서 앞부분을 잃지 않는다.
- *
- * ── 무엇을 겪었나 (2026-08-20) ──────────────────────────────────────────────
- * `_foldHistorySummary` 는 **메시지를 보낼 때마다** 그 세션의 대화를 처음부터 끝까지 읽었다
- * (`creator` 조인까지). 정작 쓰는 것은 두 조각뿐이다: 마지막 `maxTurns`개와, 요약 워터마크
- * 뒤부터의 미반영분. 대화가 2,000개면 매 메시지마다 2,000행을 읽어 수십 행을 쓴 셈이다.
- *
- * 같은 종류의 결함을 트윈 쪽에서 먼저 잡았다(`timeRange` — min/max 두 수를 구하려고 저널 27만
- * 행을 4초마다 읽었다). 사람 리뷰가 그것을 못 잡은 이유는 **코드가 맞았기 때문**이다. 여기도 같다:
- * 답은 맞고 비용만 틀렸다. 그래서 이 시험은 답과 함께 **어디까지 읽어야 하는가**를 못 박는다.
- *
- * ── 지키는 것 ───────────────────────────────────────────────────────────────
- * ① 창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 워터마크로 또 자르지 않는다.
- * ② 전체를 읽어 왔으면 워터마크로 자른다 — 이미 요약에 담은 것을 두 번 담지 않는다.
- * ③ 두 경로가 **같은 답**을 낸다. 읽는 범위를 바꾼 것이 요약 내용을 바꾸면 안 된다.
- * ④ 워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리는 쪽보다 다시 요약하는 쪽이 안전하다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-
-/*
- * 컴파일 산출물에서 불러온다 — 소스는 `./history-summary.js` 형태로 상대 임포트를 하고, 시험 로더는
- * 그 `.js` 를 `.ts` 로 되돌려 주지 않는다(이 저장소의 다른 엔진 시험도 같은 이유로 dist 를 쓴다).
- */
-const req = createRequire(import.meta.url)
-const { foldHistorySummary } = req('../dist-server/service/chat-message/fold-history.js')
-const { splitByCap, pendingForSummary } = req('../dist-server/service/chat-message/history-summary.js')
-
-const MAX_TURNS = 5
-const THRESHOLD = 3
-
-/** 메시지 n개 — id 는 `m1`.. 로 두어 어디까지 담겼는지 눈으로 읽을 수 있게 한다. */
-const rows = (n: number, from = 1) =>
-  Array.from({ length: n }, (_, i) => ({
-    id: `m${from + i}`,
-    role: (from + i) % 2 ? 'user' : 'assistant',
-    content: `말 ${from + i}`
-  }))
-
-/** 요약기를 가로채 **무엇이 요약 대상이 됐는지** 본다. 이것이 이 시험의 핵심 관측점이다. */
-function capturing() {
-  const seen: string[] = []
-  return {
-    seen,
-    summarize: async (content: string) => {
-      seen.push(content)
-      return '요약'
-    }
-  }
-}
-
-test('창으로 읽어 왔으면 밀려난 것이 곧 미반영분이다 — 워터마크로 또 자르지 않는다', async () => {
-  /* m1..m9 가 창(요약 뒤부터)이다. 마지막 5개는 원문 유지, 앞 4개가 새로 밀려났다. */
-  const cap = capturing()
-  const r = await foldHistorySummary({
-    rows: rows(9),
-    rowsStartAfterSummary: true,
-    stored: { text: '앞선 요약', upToMessageId: 'm0-요약에-담긴-것' },
-    maxTurns: MAX_TURNS,
-    threshold: THRESHOLD,
-    summarize: cap.summarize
-  })
-
-  assert.ok(r.patch, '4개가 밀려났고 임계치 3 이상이므로 접는다')
-  assert.equal(r.patch!.summaryUpToMessageId, 'm4', '밀려난 마지막까지 담았다고 기록한다')
-  assert.match(cap.seen[0], /말 1/, '창의 첫 메시지가 요약에 들어간다')
-  assert.match(cap.seen[0], /말 4/)
-  assert.doesNotMatch(cap.seen[0], /말 5/, '유지분은 원문으로 남으므로 요약에 넣지 않는다')
-  assert.match(cap.seen[0], /앞선 요약/, '앞선 요약에 이어 붙인다 — 앞부분을 잃지 않는다')
-})
-
-test('전체를 읽어 왔으면 워터마크로 자른다 — 이미 담은 것을 두 번 담지 않는다', async () => {
-  /* m1..m14 전체. m5 까지 요약에 담겼다 → 미반영분은 m6..m9(마지막 5개는 유지분). */
-  const cap = capturing()
-  const r = await foldHistorySummary({
-    rows: rows(14),
-    stored: { text: '앞선 요약', upToMessageId: 'm5' },
-    maxTurns: MAX_TURNS,
-    threshold: THRESHOLD,
-    summarize: cap.summarize
-  })
-
-  assert.ok(r.patch)
-  assert.equal(r.patch!.summaryUpToMessageId, 'm9')
-  assert.doesNotMatch(cap.seen[0], /말 5(?!\d)/, 'm5 는 이미 요약에 담겼다')
-  assert.match(cap.seen[0], /말 6/)
-  assert.match(cap.seen[0], /말 9/)
-})
-
-test('읽는 범위를 바꿔도 요약 대상은 같다 — 성능을 바꾼 것이 내용을 바꾸지 않는다', async () => {
-  /*
-   * 같은 상황을 두 방식으로 읽는다. 전체는 m1..m14 이고 m5 까지 요약됨. 창은 그 뒤인 m6..m14.
-   * 둘의 요약 대상이 다르면, 이 최적화가 사실을 옮긴 것이다.
-   */
-  const whole = capturing()
-  const windowed = capturing()
-
-  const a = await foldHistorySummary({
-    rows: rows(14),
-    stored: { text: '앞선 요약', upToMessageId: 'm5' },
-    maxTurns: MAX_TURNS,
-    threshold: THRESHOLD,
-    summarize: whole.summarize
-  })
-  const b = await foldHistorySummary({
-    rows: rows(9, 6),
-    rowsStartAfterSummary: true,
-    stored: { text: '앞선 요약', upToMessageId: 'm5' },
-    maxTurns: MAX_TURNS,
-    threshold: THRESHOLD,
-    summarize: windowed.summarize
-  })
-
-  assert.equal(whole.seen[0], windowed.seen[0], '요약에 들어가는 글이 글자까지 같다')
-  assert.deepEqual(a.patch, b.patch, '기록하는 워터마크도 같다')
-})
-
-test('워터마크 행이 사라졌으면 전부 미반영으로 본다 — 빠뜨리지 않는다', () => {
-  /* 삭제·편집으로 그 id 가 이력에 없을 수 있다. 그때 덮은 범위를 알 수 없으므로 전부 다시 본다. */
-  const { dropped } = splitByCap(rows(14), MAX_TURNS)
-  const pending = pendingForSummary(dropped, { text: '앞선 요약', upToMessageId: '지워진-id' })
-
-  assert.equal(pending.length, dropped.length, '전부 미반영')
-  assert.equal(pending[0].id, 'm1')
-})
-
-test('창이 유지분보다 짧으면 접지 않는다 — 새로 밀려난 것이 없다', async () => {
-  const cap = capturing()
-  const r = await foldHistorySummary({
-    rows: rows(MAX_TURNS),
-    rowsStartAfterSummary: true,
-    stored: { text: '앞선 요약', upToMessageId: 'm0' },
-    maxTurns: MAX_TURNS,
-    threshold: THRESHOLD,
-    summarize: cap.summarize
-  })
-
-  assert.equal(r.patch, null)
-  assert.equal(r.skipped, 'nothing-dropped')
-  assert.equal(cap.seen.length, 0, 'LLM 을 부르지 않는다')
-})
-
-test('밀려난 것이 임계치 미만이면 접지 않는다 — 매 턴 요약하지 않는다', async () => {
-  const cap = capturing()
-  const r = await foldHistorySummary({
-    rows: rows(MAX_TURNS + THRESHOLD - 1),
-    rowsStartAfterSummary: true,
-    stored: { text: '앞선 요약', upToMessageId: 'm0' },
-    maxTurns: MAX_TURNS,
-    threshold: THRESHOLD,
-    summarize: cap.summarize
-  })
-
-  assert.equal(r.skipped, 'below-threshold')
-  assert.equal(cap.seen.length, 0)
-})