@things-factory/headless-twin 10.0.14 → 10.0.17

package/server/service/twin-model/isa95-coverage.ts

@@ -54,6 +54,19 @@ export interface Isa95Concept {
    * 라고만 말하면 **표가 스스로 모순된 말을 한다**(다 됐다면서 없다고 한다).
    *
    * 그래서 축일 수 없는 것은 갈 곳을 가리킨다. 여기가 비어 있고 축도 없으면 그것은 **진짜 빈칸**이다.
+   *
+   * ── ★ 뜻을 고쳐 적는다 (2026-08-24, 사용자 지적) ──────────────────────────
+   * 한때 이 칸을 「**어디서 보이나**」로 읽고, 화면이 그것을 「해당 축 항목에 표시됩니다」라는 문장으로
+   * 냈다. 두 가지가 잘못이었다.
+   *
+   *  ① 그 문장은 **한국어가 아니었다**(사용자 지적). 그리고 칩이 이미 갈 곳을 보이므로 **군더더기**다.
+   *  ② 뜻이 틀렸다. 이 칸은 「**어디에 속하나**」다 — 그 개념이 자기 목록을 갖지 않고 **어느 축의 안에
+   *     들어 있나**. 화면에 그려지는지는 `surface` 가 따로 답한다. 둘은 다른 물음이다.
+   *
+   * 그래서 **`surface` 와 짝을 맞추지 않는다.** 자기 축이 없으면 언제나 갈 곳을 적는다 — 아직 그려지지
+   * 않는 개념도 **어디에 속하는지는 사실**이고, 그것을 비우면 「어디에도 없는 것」으로 읽힌다.
+   *
+   * 여기가 비어 있고 축도 없으면 그것은 **진짜 빈칸**이다(위 규칙).
    */
   shownOn?: string[]
 }
@@ -114,7 +127,17 @@ const PART2: Isa95Concept[] = [
    * `TestSpecificationID`(로트별 기준 참조 — 품목 정의가 대신 답하므로 두지 않았다) · `Status` ·
    * `HierarchyScope` · `Version`. 채운 것만 세는 것이 이 표의 규율이다.
    */
-  { std: 'MaterialLot', part: '2', label: 'twin.isa95.MaterialLot', axis: null, structure: 'partial', behavior: 'full', surface: 'partial', note: 'twin.isa95.note.lot' },
+  /*
+   * ── 2026-08-25 — 목록이 쌓이기만 하던 것을 고쳤다 ──────────────────────────
+   * 연결된 시스템은 매 주기 현재 재고를 전부 보내는데, 트윈은 그것을 낱낱의 관측으로 받아 **더하기만
+   * 했다.** 「그리고 이것 말고는 없다」를 받는 곳이 없어서 목록에서 빠진 줄이 영원히 남았다.
+   * 실측: 실제 1,704건인데 트윈이 10,038건.
+   *
+   * 그동안 이 줄은 「기능 있음」이었다. **현재 재고를 맞게 유지하지 못하는 상태로 그렇게 적을 수
+   * 없다.** 오늘 「이 목록이 전부다」를 받는 길을 냈고(커널 0.7.63), 수량으로 온 재고도 없어질 수
+   * 있게 했다. 이제 사실이다.
+   */
+  { std: 'MaterialLot', part: '2', label: 'twin.isa95.MaterialLot', axis: 'items', structure: 'partial', behavior: 'full', surface: 'partial', note: 'twin.isa95.note.lot' },
   /*
    * ── 2026-08-24 판정 정정: `none` 이 아니었다 ──────────────────────────────
    * 이 줄은 셋 다 `none` 이었는데 **표가 코드보다 뒤처져 있었다.** 커널은 서브로트를 든다:
@@ -124,7 +147,7 @@ const PART2: Isa95Concept[] = [
    *   `itemKeyOf(item)`      **개체의 정체성이 이 값이다** — `subLotId ?? epc`
    *
    * 기능이 `full` 인 근거: 이 축이 없으면 같은 로트를 rack-1 에 100개·rack-2 에 60개 관측했을 때
-   * **뒤에 온 관측이 앞을 덮어 100개가 조용히 사라진다**(합계 160 → 60). 실제로 그 결함을 이 축으로
+   * **뒤에 온 관측이 앞을 덮어 100개가 오류 없이 사라진다**(합계 160 → 60). 실제로 그 결함을 이 축으로
    * 고쳤다. 즉 장식이 아니라 정체성을 지탱한다.
    *
    * 구조가 `partial` 인 이유: 서브로트는 로트와 같은 모양이고(위 참조) 그 로트가 `partial` 이다.
@@ -134,7 +157,7 @@ const PART2: Isa95Concept[] = [
    * 이 부류(코드에 있는데 표가 `none`)는 자동으로 잡히지 않는다 — 표의 가드는 반대 방향만 본다
    * (축이 사라지면 구조를 내린다). 그래서 축을 늘릴 때 이 표를 함께 보는 것이 규율이다.
    */
-  { std: 'MaterialSublot', part: '2', label: 'twin.isa95.MaterialSublot', axis: null, structure: 'partial', behavior: 'full', surface: 'partial' },
+  { std: 'MaterialSublot', part: '2', label: 'twin.isa95.MaterialSublot', axis: null, shownOn: ['items'], structure: 'partial', behavior: 'full', surface: 'partial' },
   { std: 'ProcessSegment', part: '2', label: 'twin.isa95.ProcessSegment', axis: 'operations', structure: 'full', behavior: 'full', surface: 'full' },
   /*
    * 속성은 자원마다 붙는 확장이라 **자기 축이 아니다** — 그래서 `axis` 는 없지만 구조는 완전하다:
@@ -144,7 +167,7 @@ const PART2: Isa95Concept[] = [
    * 기능은 **부분**이다: 호스트의 주행 추정기가 `speed` 를 읽어 이동 시간을 만드는 것이 유일한 소비처다
    * (다른 속성은 아직 아무도 읽지 않는다). 그 사실을 `full` 로 올리면 표가 거짓이 된다.
    */
-  { std: 'Property', part: '2', label: 'twin.isa95.Property', axis: null, structure: 'full', behavior: 'partial', surface: 'full', note: 'twin.isa95.note.property' },
+  { std: 'Property', part: '2', label: 'twin.isa95.Property', axis: null, shownOn: ['equipment', 'persons', 'assets'], structure: 'full', behavior: 'partial', surface: 'full', note: 'twin.isa95.note.property' },
   /*
    * **자리의 상시 관측** — 2026-08-24 신설(커널 0.7.56). 표에 이 개념이 아예 없었다.
    *
@@ -162,11 +185,25 @@ const PART2: Isa95Concept[] = [
    * 계층이고 냉장실은 `StorageZone` 수준의 설비다. `OperationalLocationType` 에는 이 축이 없다.
    *
    * 구조가 `partial`: 봉투 전체(`ID`·`Description`·사건 분류·`OperationsRecord` 구조)가 아니라 관측
-   * 하나를 담는 데 필요한 칸만 든다.
+   * 하나를 담는 데 필요한 칸만 든다. 2026-08-25 에 지난 기록의 봉투가 사람이 적은 문장을 함께
+   * 나르게 됐지만(`CanonicalEnvelope.description`), 그것은 **기록에 남는 말**이고 이 타입의
+   * `Description` 칸이 아니다 — 상태에 담기지 않으므로 이 줄의 등급을 올리지 않는다.
    * 기능이 `full`: 사건 채널(`location.measured`)이 상태를 만들고, 선언된 기준으로 판정해
    * `observation-out-of-limit` 신호를 세운다.
    * 화면이 `none`: 클라이언트에 이 축을 그리는 곳이 없다(실측 0곳).
    */
+  /*
+   * ── 2026-08-25 — 이 줄이 실제보다 높게 적혀 있었다 ────────────────────────
+   * 「기능 있음」으로 적어 두었다. 커널이 관측을 반영하고 기준으로 판단하는 것은 사실이었으므로
+   * 그렇게 적었는데, **연결된 시스템이 그 값을 보낼 길이 없었다** — 유입 경로가 `locationId` 를
+   * 보지 않아 「어느 사실인지 모른다」로 거부했다.
+   *
+   * **아무도 먹일 수 없는 기능은 동작하는 기능이 아니다.** 오늘 그 경로를 냈고(커널 0.7.62),
+   * 이제 「기능 있음」이 사실이다. 그때까지는 「일부」였어야 했다.
+   *
+   * 같은 부류를 오늘 세 번 만났다 — 표가 **할 수 있는 일을 못 한다고** 적은 것이 여섯 줄이었고,
+   * 이것은 반대로 **못 하는 일을 할 수 있다고** 적은 것이다. 뒤쪽이 더 위험하다.
+   */
   { std: 'OperationsEvent', part: '2', label: 'twin.isa95.OperationsEvent', axis: null, shownOn: ['locations'], structure: 'partial', behavior: 'full', surface: 'none' }
 ]
 
@@ -189,7 +226,7 @@ const PART4: Isa95Concept[] = [
    *
    * `surface` 도 `full` 이다(같은 날 두 번째 단계): 목록·상세·관계에 더해 **과거로 다시 계산하는 길**이 화면에
    * 있다 — 시각 커서를 옮기면 그 시점의 사실이 나오고, 무엇을 근거로 답했는지도 화면이 말한다
-   * (라이브=권위 · 저널=파생 · 접은 리비전). 실측: 이른 시각 0건 · 하루 뒤 504건.
+   * (라이브=권위 · 저널=파생 · 계산한 리비전). 실측: 이른 시각 0건 · 하루 뒤 504건.
    */
   { std: 'OperationsSchedule', part: '4', label: 'twin.isa95.OperationsSchedule', axis: 'orders', structure: 'full', behavior: 'full', surface: 'full', note: 'twin.isa95.note.schedule' },
   { std: 'OperationsPerformance', part: '4', label: 'twin.isa95.OperationsPerformance', axis: 'tasks', structure: 'full', behavior: 'full', surface: 'full', note: 'twin.isa95.note.performance' },
@@ -244,10 +281,10 @@ export const ISA95_CONCEPTS: Isa95Concept[] = [...PART2, ...PART4]
  * 적합성 보고 — **채운 것과 빠진 것을 함께.**
  *
  * `axis` 를 커널 축 목록과 맞춰 본다: 축이 있다고 적혀 있는데 커널에 없으면 그 선언이 낡은 것이므로
- * **구조 없음으로 낮추고 그 사실을 말한다**(조용히 통과시키면 이 표가 거짓이 된다).
+ * **구조 없음으로 낮추고 그 사실을 말한다**(알리지 않고 통과시키면 이 표가 거짓이 된다).
  */
 /**
- * 선언한 축을 커널의 축 목록과 맞춘다 — **어긋난 것을 조용히 지우지 않는다.**
+ * 선언한 축을 커널의 축 목록과 맞춘다 — **어긋난 것을 알리지 않고 지우지 않는다.**
  *
  * 두 자리가 어긋날 수 있다.
  *  · `axis` — 그 개념 자신의 문. 커널에 없으면 구조를 「없음」으로 낮추고 그 사실을 말한다.

package/server/service/twin-model/item-ref.ts

@@ -1,7 +1,7 @@
 /*
  * **개체에서 품목으로** — 정체성 모양이 하나가 아니다 (2026-08-23).
  *
- * ── 무엇이 조용히 비어 있었나 ───────────────────────────────────────────────
+ * ── 무엇이 알리지 않고 비어 있었나 ───────────────────────────────────────────────
  * 화면이 「이 개체는 선언된 자재가 아닙니다(라인 내부의 중간 산물일 수 있습니다)」라고 말했는데, 그
  * 품목은 원본의 선언에 이름까지 있었다(「냉동그린빈스」). 대응 표(`productionSpec.binding`)도 멀쩡했다.
  *
@@ -11,7 +11,7 @@
  *   https://…/class/product-M0000438@M2R0001  →  null    (모르던 모양)
  *
  * 웹 URI 로 정체성을 말하는 원본에서는 언제나 `null` 이 나왔고, 그래서 **개체를 자재에 이을 수 없었다.**
- * 그 결과가 화면 두 곳에서 조용한 빈칸이었다(계보 적합성 · 오더가 무엇을 만드나). 「없으면 붙이지
+ * 그 결과가 화면 두 곳에서 들어온 것이 없는 빈칸이었다(계보 적합성 · 오더가 무엇을 만드나). 「없으면 붙이지
  * 않는다」는 규율을 지키기 때문에 아무 오류도 나지 않았다.
  *
  * ── 무엇을 돌려주나 ─────────────────────────────────────────────────────────

package/server/service/twin-model/name-index.ts

@@ -16,7 +16,7 @@ export const at = (o: any, path: string) => path.split('.').reduce((a: any, k: s
  *
  * 도메인 모양을 코드가 아는 것이 아니라 **식별자 관례**를 아는 것이다. 후보를 순서대로 보고 첫
  * 값을 쓴다. 하나도 없으면 그 항목은 가리킬 수 없으므로 `null` — 목록에서 빼지 않고 **id 없음**으로
- * 낸다(조용히 빠지면 건수가 안 맞는다).
+ * 낸다(오류 없이 빠지면 건수가 안 맞는다).
  */
 export const idOf = (o: any, info?: { idField?: string | string[] }): string | null => {
   if (typeof o === 'string') return o

package/server/service/twin-model/project-structure.ts

@@ -26,7 +26,7 @@ export interface ProjectionReport {
   locations: number
   equipment: number
   operations: number
-  /** 자리를 못 찾아 기준 자리를 비운 설비 — **조용히 넘기지 않는다.** */
+  /** 자리를 못 찾아 기준 자리를 비운 설비 — **알리지 않고 넘기지 않는다.** */
   unresolvedHome: string[]
   /** 구역을 못 찾아 비운 자리. 구역은 model 밖(호스트 개념)이라 어긋날 수 있다. */
   unresolvedArea: string[]
@@ -48,7 +48,7 @@ export async function projectStructure(domainId: string, instanceId: string, mod
    * 실측(2026-08-18): 현장 값을 그 현장의 트윈 전부에 얹다가 한 트윈에서 투영이 터졌다. 올라온 것은
    * `SQLITE_CONSTRAINT: UNIQUE constraint failed: twin_equipment...` 뿐이라 **무엇이 잘못됐는지 아무도
    * 알 수 없었다.** 원인은 그 모델에 설비 `load-1` 이 두 번 들어 있던 것이다(id 는 트윈 안에서 유일해야
-   * 한다). 조용히 하나만 남기지 않는다 — 그것은 모델링 오류를 감추는 일이고, 어느 쪽이 맞는지 우리는
+   * 한다). 알리지 않고 하나만 남기지 않는다 — 그것은 모델링 오류를 감추는 일이고, 어느 쪽이 맞는지 우리는
    * 모른다.
    */
   const dupOf = (list: any[] | undefined, what: string): string | undefined => {
@@ -117,7 +117,7 @@ export async function projectStructure(domainId: string, instanceId: string, mod
         parallelism: l.parallelism ?? null,
         area: area ? ({ id: area.id } as any) : null,
         gs1Id: l.gs1Id ?? null,
-        /* 자리의 속성도 옮긴다 — 옮기지 않으면 계약전력·요금이 항목 패널에서 사라진다(조용한 누락). */
+        /* 자리의 속성도 옮긴다 — 옮기지 않으면 계약전력·요금이 항목 패널에서 사라진다(들어온 것이 없는 누락). */
         properties: l.properties ?? null,
         sourceRef,
         ingestedAt
@@ -173,7 +173,7 @@ export async function projectStructure(domainId: string, instanceId: string, mod
         intent: o.intent ?? null,
         locationType: o.locationType ?? null,
         resourceType: o.resourceType ?? null,
-        /* 소요시간은 ISO 8601 문자열이 정본 — 분으로 접으면 초가 조용히 사라진다. */
+        /* 소요시간은 ISO 8601 문자열이 정본 — 분으로 줄이면 초가 오류 없이 사라진다. */
         duration: o.duration ?? null,
         variability: o.variability ?? null,
         parameters: o.parameters ?? null,

package/server/service/twin-model/twin-equipment.ts

@@ -14,7 +14,7 @@ import { TwinLocation } from './twin-location.js'
  *
  * ── 테이블 이름을 명시한다 ──────────────────────────────────────────────────
  * `equipment` 는 영어에서 **불가산**이라 자동 복수화가 다른 표들과 규칙이 어긋난다
- * (`twin_locations` 인데 `twin_equipment`). 조용한 비일관은 나중에 "왜 이것만 다르지" 를
+ * (`twin_locations` 인데 `twin_equipment`). 들어온 것이 없는 비일관은 나중에 "왜 이것만 다르지" 를
  * 만들므로 이름을 고정한다(ADR-0032-I).
  */
 @Entity({ name: 'twin_equipment' })
@@ -97,7 +97,7 @@ export class TwinEquipment {
    * 그 시험들의 **결과** — 자격이 성립하는지는 이것이 말한다.
    *
    * 참조만 있으면 "무엇으로 검증한다" 까지다. 오늘 이 저장소에서 네 번 나온 결손과 같은 부류이므로
-   * 행에 자리를 함께 만든다 — 모델에는 있는데 행에 없으면 화면이 조용히 잃는다.
+   * 행에 자리를 함께 만든다 — 모델에는 있는데 행에 없으면 화면이 알리지 않고 잃는다.
    */
   @Column({ type: 'simple-json', nullable: true })
   @Field(type => ScalarObject, { nullable: true, description: 'Results of those tests (pass/fail with dates). Declared by the source — the twin does not produce them.' })

package/server/service/twin-model/twin-lineage-query.ts

@@ -52,11 +52,22 @@ export class TwinLineageQuery {
      * 변환 이벤트만 읽는다. **최신부터** 읽는다 — 계보를 묻는 개체는 대개 최근에 만들어진 것이고,
      * 창을 넘겨 잘릴 때 잃는 쪽이 오래된 것이어야 덜 아프다.
      */
-    const rows: any[] = await getRepository(TwinEvent).find({
-      where: { domain: { id: domainId } as any, instanceId, eventType: 'epcis.TransformationEvent' } as any,
-      order: { eventTime: 'DESC' } as any,
-      take: windowCap
-    })
+    /*
+     * 관계를 **컬럼으로** 묻는다 (2026-08-28). `find({ where: { domain: { id } } })` 은 관계를 가진
+     * 엔티티에서 두 단계 질의가 되고 **안쪽에 상한이 없다** — `take` 가 있어도 조건에 맞는 행을 전부
+     * 만든 뒤 밖에서 자른다. 변환 사건이 적은 트윈에서는 표가 안 나지만, 변환을 많이 내는 트윈에서는
+     * 이 한 번이 그 종류 전체를 만든다. 질의 빌더로 물으면 상한이 안쪽에 걸린다.
+     *
+     * 종류가 정확일치이므로 `(domain, instance, event_type, event_time)` 색인이 시각 순서까지 준다.
+     */
+    const rows: any[] = await getRepository(TwinEvent)
+      .createQueryBuilder('e')
+      .where('e.domain = :domainId', { domainId })
+      .andWhere('e.instanceId = :instanceId', { instanceId })
+      .andWhere('e.eventType = :eventType', { eventType: 'epcis.TransformationEvent' })
+      .orderBy('e.eventTime', 'DESC')
+      .limit(windowCap)
+      .getMany()
     const truncated = rows.length >= windowCap
 
     /* 산출 → 그 변환. 한 개체는 한 번만 만들어지지만, 데이터가 그렇지 않을 수 있으므로 목록으로 든다. */

package/server/service/twin-model/twin-location.ts

@@ -115,7 +115,7 @@ export class TwinLocation {
    * ── 왜 늦게 생겼나 (2026-08-18) ────────────────────────────────────────────
    * 설비 행에는 이 칸이 있었는데 자리 행에는 없었다. 그래서 수전 지점에 계약전력·요금을 넣어도 **항목
    * 패널의 「원본이 말한 값」에 그 줄이 아예 없었다** — 사용자는 값을 넣고도 화면에서 찾을 수 없었고,
-   * 「이 값이 무엇을 바꾸나」는 문장도 붙을 자리가 없었다(조용한 누락).
+   * 「이 값이 무엇을 바꾸나」는 문장도 붙을 자리가 없었다(들어온 것이 없는 누락).
    */
   @Column({ type: 'simple-json', nullable: true })
   @Field(type => ScalarObject, { nullable: true, description: 'Properties declared on this location (ISA-95 Property: value + dataType + unit of measure). Carries locally-declared numbers too, with source: local.' })

package/server/service/twin-model/twin-model-item-query.ts

@@ -54,7 +54,7 @@ function matches(o: any, q: string): boolean {
  * 그래서 야드의 도크도어나 에너지의 계량기가 늘어도 여기 손댈 것이 없다(ADR-0031). 이 파일에
  * 도메인 이름이 한 번도 나오지 않는 것이 그 증거다.
  *
- * ── 조용히 자르지 않는다 ──────────────────────────────────────────────────────
+ * ── 알리지 않고 자르지 않는다 ──────────────────────────────────────────────────────
  * 목록은 항상 **총 건수**와 함께 온다. 그리고 어떻게 셌는지(`basis`)를 밝힌다 — 행이면 DB 가
  * 페이징했고, 문서면 서버가 문서를 통째로 읽어 잘라 냈다. 후자는 규모에서 한계가 되므로 그 사실이
  * 화면에 드러나야 이주 압력이 살아 있다.
@@ -118,7 +118,7 @@ export class TwinModelItemQuery {
       /*
        * 검색은 아직 DB 로 내리지 않았다. **그 사실을 밝힌다**(`basis: 'rows-scanned'`) —
        * 흉내로 덮으면 규모가 오는 날까지 아무도 이 한계를 모른다. 훑는 건수를 상한으로 막고,
-       * 상한에 닿았으면 잘렸다고 말한다(조용히 자르지 않는다).
+       * 상한에 닿았으면 잘렸다고 말한다(알리지 않고 자르지 않는다).
        */
       const SCAN_MAX = 5000
       const repo = getRepository(row.entity)
@@ -159,11 +159,11 @@ export class TwinModelItemQuery {
        * **라이브는 권위, 히스토리는 파생.**
        *
        * 지금 도는 커널의 상태가 이 축의 진실이다. 그런데 커널이 멈춰 있거나 사용자가 **과거 시각**을
-       * 물으면 답할 것이 없어진다 — 그때 저널을 그 시점까지 접어 답한다(`recover`). 둘은 같은 모양이지만
+       * 물으면 답할 것이 없어진다 — 그때 저널을 그 시점까지 계산해 답한다(`recover`). 둘은 같은 모양이지만
        * **성질이 다르므로 `basis` 로 구별해 낸다**: 파생을 권위처럼 내면 다시 계산한 값을 보고 "지금 이렇다"
        * 로 읽게 된다.
        *
-       * 규모: 접기 비용은 이벤트 수에 비례한다. 감추지 않고 **어느 리비전까지 접었는지 함께 낸다** —
+       * 규모: 계산 비용은 이벤트 수에 비례한다. 감추지 않고 **어느 리비전까지 계산했는지 함께 낸다** —
        * 이 화면이 목록마다 `basis` 를 밝혀 온 규율 그대로다.
        */
       const live = TwinEngine.isRunning(domainId, instanceId) && !at_
@@ -341,9 +341,9 @@ export class TwinModelItemQuery {
      */
     if (axisSource(axis) === 'state') {
       /*
-       * 동작하지 않으면 **목록과 같은 길로 저널을 접는다.**
+       * 동작하지 않으면 **목록과 같은 길로 저널을 계산한다.**
        *
-       * 목록만 접고 상세는 안 접었더니, 목록에는 472건이 보이는데 그 줄을 열면 "자기 속성이 없습니다"
+       * 목록만 계산하고 상세는 안 계산했더니, 목록에는 472건이 보이는데 그 줄을 열면 "자기 속성이 없습니다"
        * 가 나왔다 — 한 화면에서 두 답이 갈리면 어느 쪽이 맞는지 사용자가 알 수 없다.
        */
       const liveItem = TwinEngine.isRunning(domainId, instanceId)
@@ -471,7 +471,7 @@ export class TwinModelItemQuery {
       observed,
       /*
        * 관측 열이 **자기 근거를 말한다** — 목록의 그 낱말 그대로(`state`=라이브 권위, `journal`=다시 계산한
-       * 파생). 없으면 비교하지 못한 것이다. 파생이면 몇 번째 리비전까지 접었는지 함께 낸다.
+       * 파생). 없으면 비교하지 못한 것이다. 파생이면 몇 번째 리비전까지 계산했는지 함께 낸다.
        */
       ...('value' in seen
         ? { observedBasis: seen.basis, ...(seen.foldedRevision != null ? { observedRevision: seen.foldedRevision } : {}) }
@@ -631,8 +631,8 @@ export class TwinModelItemQuery {
    *
    * 근거를 값과 함께 낸다 — 목록이 오래 해 온 그대로다(§twinModelItemList). 라이브(권위)와 저널
    * 폴드(파생)는 **같은 모양의 객체**라서, 근거가 없으면 다시 계산한 값을 "지금 이렇다" 로 읽는다. 근거를
-   * 실을 자리가 없던 동안에는 멈춘 트윈의 저널을 아예 접지 않고 `—` 로 두는 편이 정직했다. 이제
-   * 자리가 있으니 접는다 — 멈춘 트윈에도 마지막으로 알던 사실이 있고, 그것을 감출 이유는 없다.
+   * 실을 자리가 없던 동안에는 멈춘 트윈의 저널을 아예 계산하지 않고 `—` 로 두는 편이 정직했다. 이제
+   * 자리가 있으니 계산한다 — 멈춘 트윈에도 마지막으로 알던 사실이 있고, 그것을 감출 이유는 없다.
    *
    * 다시 계산할 것이 없으면(모델도 저널도 없다) `null` 이다 — **없는 것과 비교하지 못한 것은 다르다.**
    */
@@ -652,9 +652,9 @@ export class TwinModelItemQuery {
         const rec = await TwinEngine.recover(domainId, instanceId)
         folded = Number((rec as any)?.revision) || undefined
         /*
-         * **이벤트를 하나도 접지 않은 폴드는 관측이 아니다.** 저널이 비어도 복원은 선언을 다시 투영한
+         * **이벤트를 하나도 계산하지 않은 폴드는 관측이 아니다.** 저널이 비어도 복원은 선언을 다시 투영한
          * 기준선을 돌려준다 — 그것을 "트윈이 관측한 값" 열에 실으면 **선언이 관측으로 위장한다**
-         * (원본이 말한 값이 오른쪽에도 똑같이 앉아, 견준 것처럼 보인다). 접은 것이 없으면 없다고 한다.
+         * (원본이 말한 값이 오른쪽에도 똑같이 앉아, 견준 것처럼 보인다). 계산한 것이 없으면 없다고 한다.
          */
         if (folded == null) return { absence: 'not-running' as const }
         state = unwrapState(rec)
@@ -700,7 +700,7 @@ export class TwinModelItemQuery {
     const model = inst.model ?? {}
 
     /*
-     * 관측 축의 항목들 — **한 번만** 읽는다(관계마다 다시 접으면 저널을 여러 번 접는다).
+     * 관측 축의 항목들 — **한 번만** 읽는다(관계마다 다시 계산하면 저널을 여러 번 계산한다).
      * 라이브가 있으면 그것, 없으면 저널 폴드. 없으면 빈 배열(없는 것을 지어내지 않는다).
      */
     let observedState: any
@@ -725,7 +725,7 @@ export class TwinModelItemQuery {
      *
      * 관계 선언의 필드 이름(`locations.parentId`)은 **원본 문서의 어휘**다. 행은 같은 사실을 자기
      * 컬럼 이름으로 담는다(자리의 구역은 `area` FK). 행을 보고 `parentId` 를 찾으면 늘 비어서
-     * "이어진 것이 없다" 로 조용히 답한다 — 실제로 그랬다.
+     * "이어진 것이 없다" 로 알리지 않고 답한다 — 실제로 그랬다.
      *
      * 어느 쪽이 정본인가로 구분하면 답이 분명하다: 관계를 선언한 어휘가 문서 어휘이므로 **문서에서
      * 푼다.** 행에만 있고 문서에 없는 항목(있을 수 있다)은 이어진 것이 비지만, 그것은 사실이다.
@@ -762,7 +762,7 @@ export class TwinModelItemQuery {
         const repo = getRepository(row.entity)
         /*
          * **FK 는 부르지 않으면 오지 않는다.** 관계 필드를 로딩하지 않고 조회하면 값이 늘 `undefined`
-         * 라서 "나를 가리키는 것이 하나도 없다" 로 조용히 답한다 — 실제로 그랬다(설비 둘이 이 자리를
+         * 라서 "나를 가리키는 것이 하나도 없다" 로 알리지 않고 답한다 — 실제로 그랬다(설비 둘이 이 자리를
          * 기준으로 삼는데 이웃이 비어 있었다).
          *
          * 어느 필드가 관계인지는 **엔티티 메타데이터**가 안다. 축마다 표를 두면 축이 늘 때마다

package/server/service/twin-model/twin-model-mutation.ts

@@ -71,7 +71,7 @@ async function spreadSpaceLayer(
     t.localDeclarations = out.instanceLayerApplied as any
     const running = TwinEngine.modeOf(domainId, t.instanceId)
     /*
-     * **트윈 하나가 실패해도 나머지는 받는다** — 다만 조용히 넘기지 않는다(2026-08-18 실측).
+     * **트윈 하나가 실패해도 나머지는 받는다** — 다만 알리지 않고 넘기지 않는다(2026-08-18 실측).
      *
      * 현장 선언을 처음 퍼뜨렸을 때 그 현장의 어떤 트윈에서 구조 투영이 터졌고(그 트윈 모델에 설비 id가
      * 겹쳐 있었다 — 선재 결함), 그 예외가 올라와 **한 트윈 때문에 현장 전체 선언이 실패**했다. 사용자는
@@ -132,12 +132,12 @@ export class TwinModelMutation {
    * 계량이 흐르는 트윈에서도 **금액이 영원히 나오지 않았다** — 넣을 문이 없었기 때문이다.
    *
    * 값은 `model` 에 직접 쓰지 않고 **겹**으로 보관한다: 모델은 원천의 사본이므로 다시 읽기가 그것을
-   * 새로 그리면 직접 쓴 값은 조용히 사라진다. 겹은 모델을 그릴 때마다 다시 얹힌다.
+   * 새로 그리면 직접 쓴 값은 오류 없이 사라진다. 겹은 모델을 그릴 때마다 다시 얹힌다.
    *
    * ── 돌고 있는 트윈에 어떻게 반영하나 ────────────────────────────────────────
    * 미러는 **동작 중에** 새 구조를 받는다(현실은 멈추지 않는다). 시뮬레이션은 받지 않는다 — 조건이
    * 바뀐 실험은 다른 실험이고, 커널이 그렇게 거절한다. 그때는 저장만 하고 **그 사실을 말한다**:
-   * 조용히 성공으로 답하면 사용자는 지금 화면의 수가 새 선언으로 계산된 줄로 읽는다.
+   * 알리지 않고 성공으로 답하면 사용자는 지금 화면의 수가 새 선언으로 계산된 줄로 읽는다.
    */
   @Directive('@privilege(category: "twin", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
   @Mutation(returns => ScalarObject, {
@@ -165,7 +165,7 @@ export class TwinModelMutation {
     if (!declarations?.length) return { ok: false, error: 'no declaration arrived — the declarations argument was empty' }
 
     /*
-     * 검사부터 — 받지 않은 것을 조용히 버리지 않는다(사용자는 값을 넣었다고 믿는다).
+     * 검사부터 — 받지 않은 것을 알리지 않고 버리지 않는다(사용자는 값을 넣었다고 믿는다).
      *
      * 공정 이름은 **대조로만** 걸러진다(모델에 행이 없어도 성립하는 선언이라 다른 안전망이 없다). 아직
      * 돌지도 않고 명세 행도 없는 트윈이면 목록이 `undefined` 이고, 그때는 받아 주되 답에 그 사실을 싣는다.

package/server/service/twin-model/twin-model-query.ts

@@ -1,4 +1,5 @@
 import { axisSeenInJournal } from './axis-journal-evidence.js'
+import { hydratedDate } from '../../engine/read-time.js'
 import { statusTally } from './status-tally.js'
 import { TwinEvent } from '../twin-event/twin-event.js'
 import { Arg, Ctx, Query, Resolver } from 'type-graphql'
@@ -117,8 +118,8 @@ async function emptyStateReason(domainId: string, instanceId: string, axis: stri
 /**
  * 되세운 상태를 담아 둔다 — **열쇠에 저널 끝 리비전이 들어 있어** 새 사건이 오면 저절로 낡는다.
  *
- * 접기는 저널 전체를 훑는 일이라(리비전 12만에서 2~3초) 모델 화면을 열 때마다 그 값을 낼 수 없다.
- * 프로세스 안에만 두고 몇 개만 남긴다 — 다시 뜨면 다시 접는다(정확함이 캐시보다 앞선다).
+ * 계산은 저널 전체를 훑는 일이라(리비전 12만에서 2~3초) 모델 화면을 열 때마다 그 값을 낼 수 없다.
+ * 프로세스 안에만 두고 몇 개만 남긴다 — 다시 뜨면 다시 계산한다(정확함이 캐시보다 앞선다).
  */
 const RECALL_CACHE = new Map<string, { snap: any; heardAt: string | null }>()
 const RECALL_CACHE_MAX = 8
@@ -181,20 +182,38 @@ export class TwinModelQuery {
     const inst = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
     if (!inst) return null
 
-    /* 어느 원본을 반영하나 — 없을 수 있다(템플릿으로 세운 트윈). 그 사실도 사실이다. */
+    /*
+     * 어느 원본을 반영하나 — 없을 수 있다(템플릿으로 세운 트윈). 그 사실도 사실이다.
+     *
+     * ── **레퍼런스 열쇠는 인스턴스 이름이 아니다** (2026-08-24 실측) ──────────────
+     * 여기서 `source: instanceId` 로 찾고 있었다. 레퍼런스 하나가 인스턴스 하나를 낳던 시절에는
+     * 두 값이 같았지만, **레퍼런스 하나가 여러 트윈을 먹이는 순간 어긋난다.**
+     *
+     *   인스턴스   operato-chef-v1-pocheon
+     *   origin     { kind: 'reference', source: 'seunghwa' }   ← 이것이 레퍼런스 열쇠다
+     *   레퍼런스    seunghwa
+     *
+     * 그래서 요약의 `source` 가 **언제나 `null`** 이었다. 레퍼런스로 세운 트윈인데 화면이 그 원본을
+     * 못 찾았고, 「마지막 동기화」도 흐름별 신선도도 그릴 자리가 아예 없었다 — 그런데 오류는 없었다
+     * (`ref ? … : null` 이 알리지 않고 갈렸다).
+     *
+     * 인스턴스가 자기 원본을 말하고 있으므로 **그 말을 먼저 듣는다.** 옛 트윈은 두 값이 같으므로
+     * 뒤의 것으로 여전히 찾힌다 — 가산적이다.
+     */
+    const refKey = (inst.origin as any)?.source || instanceId
     const ref = await getRepository(TwinReference)
-      .findOne({ where: { domain: { id: domainId }, source: instanceId } })
+      .findOne({ where: { domain: { id: domainId }, source: refKey } })
       .catch(() => null)
 
     const model = inst.model ?? {}
     /*
-     * **한 요청에 저널은 한 번만 접는다.**
+     * **한 요청에 저널은 한 번만 계산한다.**
      *
      * 관측 축(`orders`·`tasks`)은 상태에서 센다. 그 둘이 각자 `recover()` 를 부르고 있었고, 커널이
-     * 멈춰 있으면 그것은 **저널 전체를 다시 접는 일**이다(23,731건짜리 트윈에서 4.6초, 두 번이면 곱절).
+     * 멈춰 있으면 그것은 **저널 전체를 다시 계산하는 일**이다(23,731건짜리 트윈에서 4.6초, 두 번이면 곱절).
      * 트윈을 전부 멈춰도 이 화면이 5~7초 걸린 이유가 이것이다 — 부하가 아니라 같은 일을 두 번 한 것이다.
      *
-     * 한 번만 접어 나눠 쓴다. 값이 같아지는 것은 덤이 아니라 **옳음**이다: 두 번 접으면 그 사이에
+     * 한 번만 계산해 나눠 쓴다. 값이 같아지는 것은 덤이 아니라 **옳음**이다: 두 번 계산하면 그 사이에
      * 들어온 이벤트 때문에 오더와 작업이 서로 다른 시점의 사실이 될 수 있다.
      */
     let statePromise: Promise<{ snap: any; folded: boolean; observing: boolean }> | null = null
@@ -221,29 +240,49 @@ export class TwinModelQuery {
      * 그런데 읽기 커서가 정직해진 뒤로는 원본이 **지난 것을 다시 말하지 않는다.** 그래서 재고 741건이
      * 저널에 있는데 화면은 「0」을 보였다. 사용자가 「재고현황이 없다」고 물은 자리가 이것이다.
      *
-     * 그 0 은 사실이 아니라 **우리가 잊은 것**이다. 저널을 접으면 그대로 되살아난다(실측: 리비전
-     * 97,689 을 2.4초에 접어 물품 741 · 작업 9,145 · 지시 2,856).
+     * 그 0 은 사실이 아니라 **우리가 잊은 것**이다. 저널을 계산하면 그대로 되살아난다(실측: 리비전
+     * 97,689 을 2.4초에 계산해 물품 741 · 작업 9,145 · 지시 2,856).
      *
-     * ── 그래서 접는다. 다만 **언제 들은 값인지 함께 낸다** ──────────────────────
-     * 저널을 접는 것은 **원천이 우리에게 말한 것을 다시 세우는 일**이지, 없는 값을 심는 일이 아니다.
+     * ── 그래서 계산한다. 다만 **언제 들은 값인지 함께 낸다** ──────────────────────
+     * 저널을 계산하는 것은 **원천이 우리에게 말한 것을 다시 세우는 일**이지, 없는 값을 심는 일이 아니다.
      * 그러나 물품·재고처럼 **절대값인 축**은 우리가 못 듣는 사이 떠났을 수 있다 — 그래서 값과 함께
-     * `heardAt`(그 접기의 시계)을 낸다. 사용자가 신선도를 스스로 판정할 수 있어야 하고, 화면은 그것을
+     * `heardAt`(그 계산의 시계)을 낸다. 사용자가 신선도를 스스로 판정할 수 있어야 하고, 화면은 그것을
      * 값 옆에 적는다. 시각 없이 수만 내면 낡은 값을 지금으로 읽는다.
      *
-     * 접는 조건을 좁게 둔다: **관측 축이 비어 있고, 저널에 그 축의 사실이 있을 때만**(그 판정은 색인
-     * 한 줄이다). 그리고 한 요청에 **한 번만** 접는다 — 위 `stateOnce` 와 같은 규율이다.
+     * 계산하는 조건을 좁게 둔다: **관측 축이 비어 있고, 저널에 그 축의 사실이 있을 때만**(그 판정은 색인
+     * 한 줄이다). 그리고 한 요청에 **한 번만** 계산한다 — 위 `stateOnce` 와 같은 규율이다.
      */
     let journalPromise: Promise<{ snap: any; heardAt: string | null } | null> | null = null
     const journalOnce = () =>
       (journalPromise ??= (async () => {
         try {
-          const tip = await getRepository(TwinEvent).findOne({
-            where: { domain: { id: domainId } as any, instanceId } as any,
-            order: { revision: 'DESC' } as any
-          })
-          if (!tip?.revision) return null
           /*
-           * **한 번 접은 것을 다시 접지 않는다.** 접기는 저널 전체를 훑는 일이다(리비전 12만에서 2~3초).
+           * 관계로 묻지 않는다 — 두 단계 질의가 되어 안쪽에 상한이 없고, 그 트윈의 저널을 전부 만든 뒤
+           * 한 줄을 고른다(2026-08-28 · 같은 모양이 현장 성과 화면에서 7.2초였다). 색인의 끝만 읽는다.
+           */
+          const [tipRow, latestRow] = await Promise.all([
+            getRepository(TwinEvent)
+              .createQueryBuilder('e')
+              .select('MAX(e.revision)', 'max')
+              .where('e.domain = :domainId', { domainId })
+              .andWhere('e.instanceId = :instanceId', { instanceId })
+              .getRawOne<{ max: unknown }>(),
+            /*
+             * 「저널 끝의 사건 시각」은 **가장 늦은 사건 시각**이다 — 리비전이 가장 큰 행의 시각이
+             * 아니다. 그 둘은 어긋난다(연결된 시스템을 되읽는 트윈은 원본의 시각을 싣고 도착 순서로
+             * 리비전을 받는다). 색인의 끝을 집으므로 질의 둘이어도 각각 한 줄이다.
+             */
+            getRepository(TwinEvent)
+              .createQueryBuilder('e')
+              .select('MAX(e.eventTime)', 'at')
+              .where('e.domain = :domainId', { domainId })
+              .andWhere('e.instanceId = :instanceId', { instanceId })
+              .getRawOne<{ at: unknown }>()
+          ])
+          const tip = { revision: Number(tipRow?.max) || 0, eventTime: hydratedDate(getRepository(TwinEvent), 'eventTime', latestRow?.at) }
+          if (!tip.revision) return null
+          /*
+           * **한 번 계산한 것을 다시 계산하지 않는다.** 계산은 저널 전체를 훑는 일이다(리비전 12만에서 2~3초).
            * 이 화면은 사람이 여러 번 들어오는 자리이므로 그대로 두면 매번 그 값을 낸다 — 그리고 저널이
            * 수백만 행이 되면 그 비용이 화면을 못 쓰게 만든다.
            *
@@ -255,14 +294,14 @@ export class TwinModelQuery {
           if (hit) return hit
           const snap = unwrapState(await TwinEngine.recover(domainId, instanceId, tip.revision))
           if (!snap) return null
-          /* 그 접기의 시계가 「언제 들은 값인가」다. 없으면 저널 끝의 사건 시각으로 답한다. */
-          const out = { snap, heardAt: (snap as any).nowTime ?? tip.eventTime ?? null }
+          /* 그 계산의 시계가 「언제 들은 값인가」다. 없으면 저널 끝의 사건 시각으로 답한다. */
+          const out = { snap, heardAt: (snap as any).nowTime ?? tip.eventTime?.toISOString() ?? null }
           RECALL_CACHE.set(key, out)
           /* 오래된 열쇠부터 버린다 — 트윈 몇 개를 번갈아 봐도 메모리가 자라지 않게. */
           while (RECALL_CACHE.size > RECALL_CACHE_MAX) RECALL_CACHE.delete(RECALL_CACHE.keys().next().value as string)
           return out
         } catch {
-          /* 접지 못했으면 아무 말도 만들지 않는다 — 라이브가 말한 것을 그대로 둔다. */
+          /* 계산하지 못했으면 아무 말도 만들지 않는다 — 라이브가 말한 것을 그대로 둔다. */
           return null
         }
       })())
@@ -314,7 +353,7 @@ export class TwinModelQuery {
          *
          * 행으로 옮긴 축이라도 그 트윈이 투영을 거치지 않았으면 행은 0이다(인제스트 없이
          * warm-start 된 트윈이 그렇다). 행만 보고 답하면 문서에 자리 6개가 있는데 화면은
-         * **0 이라고 말한다** — 조용한 거짓이고, 이 프로젝트가 내내 잡아 온 바로 그 부류다.
+         * **0 이라고 말한다** — 들어온 것이 없는 거짓이고, 이 프로젝트가 내내 잡아 온 바로 그 부류다.
          *
          * 그래서 어느 하나로 메우지 않는다. 행 수를 답하되 문서 수를 함께 내고, 다르면
          * `stale` 로 표시한다 — 그 차이 자체가 "이 트윈은 투영 이후 인제스트되지 않았다" 는 정보다.
@@ -348,7 +387,7 @@ export class TwinModelQuery {
           /*
            * 관측 중인지는 **런타임이 있는지**로 본다 — 캐시된 스냅샷은 관측이 아니다.
            *
-           * 동작하지 않으면 저널을 접어 답한다(라이브=권위 · 히스토리=파생). 카드는 그 차이를 `basis` 로
+           * 동작하지 않으면 저널을 계산해 답한다(라이브=권위 · 히스토리=파생). 카드는 그 차이를 `basis` 로
            * 말한다: 파생을 권위처럼 내면 다시 계산한 수를 "지금 이만큼" 으로 읽게 된다.
            */
           const { snap, folded, observing } = await stateOnce()
@@ -359,7 +398,7 @@ export class TwinModelQuery {
           let fromJournal = false
           /*
            * 라이브가 잊은 축은 **저널에서 되세운다**(§`journalOnce`). 그 축의 사실이 저널에 있을 때만
-           * 접고, 값과 함께 「언제 들은 값인가」를 낸다 — 시각 없이 수만 내면 낡은 값을 지금으로 읽는다.
+           * 계산하고, 값과 함께 「언제 들은 값인가」를 낸다 — 시각 없이 수만 내면 낡은 값을 지금으로 읽는다.
            */
           if (!folded && Array.isArray(bucket) && bucket.length === 0) {
             const seen = await axisSeenInJournal(getRepository(TwinEvent), { domain: { id: domainId }, instanceId }, a.axis).catch(() => null)
@@ -451,7 +490,7 @@ export class TwinModelQuery {
     /*
      * **원본이 모르는데 실행 중인 것** — 커널은 마스터에 없던 자원도 이벤트로 알게 되고
      * `origin: 'observed'` 를 단다(`observed-reducer`). 그것을 표에 밀어 넣지 않는다 — 그러면
-     * 틱 루프에서 DB 로 쓰는 **두 번째 쓰기 경로**가 생기고, 실패하면 조용히 어긋난다
+     * 틱 루프에서 DB 로 쓰는 **두 번째 쓰기 경로**가 생기고, 실패하면 알리지 않고 어긋난다
      * (쓰기 경로는 인제스트 하나, ADR-0032-D).
      *
      * 대신 **여기서 비교해 낸다.** 이 차이는 숨겨야 할 불일치가 아니라 인스펙션이 답해야 할
@@ -523,11 +562,61 @@ export class TwinModelQuery {
           recipeLabel: material?.label ?? material?.name ?? null
         }
       })(),
+      /*
+       * ── **식별자가 무엇에 근거하나** (2026-08-24) ──────────────────────────────
+       * 요약이 `production.companyPrefix` 를 그대로 보이는데 **그것이 발급받은 번호인지 말할 근거가
+       * 없었다.** 그래서 사용자가 긴 URI 를 보고 「GS1 을 강제하는 것인가」를 물었다 — 강제는 **이미
+       * 없고**(GS1 프리픽스가 없는 현장은 자기 도메인 아래에서 식별자를 만든다, CBV 2.0 §8.3.4)
+       * 없다는 사실이 화면에 없었던 것이 문제였다.
+       *
+       * ★ **이 축만은 무표를 쓰지 않는다.** GS1 형태의 식별자를 본 사람은 그것이 진짜 발급받은
+       * 번호라고 가정하므로, 표식이 없으면 그 가정이 곧 거짓 안심이 된다. 계약도 그렇게 적고 있다 —
+       * 「없으면 소비처는 판정하지 않는다. 기본값으로 `issued` 를 가정하면 그 화면이 곧 거짓이 된다.」
+       * 그래서 화면이 네 갈래 모두에 낱말을 붙일 수 있게 **그대로** 낸다
+       * (`claimed-issued`·`declared-namespace`·`gs1-shaped`·`kernel-constant`).
+       *
+       * 커널이 내는 것을 그대로 넘긴다 — 여기서 다시 판정하면 스냅샷과 요약이 다른 말을 한다.
+       * 트윈이 돌지 않거나 커널이 말하지 않으면 `null` 이고, 그때 화면은 **재지 않는다.**
+       */
+      identityGrounding: (await stateOnce()).snap?.identityGrounding ?? null,
       description: inst.description ?? null,
       kind: inst.kind,
       restartPolicy: inst.restartPolicy,
       source: ref
-        ? { referenceId: ref.source, adapterType: ref.adapterType, status: ref.status, lastSyncedAt: ref.lastSyncedAt }
+        ? {
+            referenceId: ref.source,
+            adapterType: ref.adapterType,
+            status: ref.status,
+            lastSyncedAt: ref.lastSyncedAt,
+            /*
+             * ── **원본의 어느 흐름이 어디까지 살아 있나** (2026-08-24) ──────────────
+             * 사용자가 「지금 데이터가 들어오는 것이 사실이냐」고 물었고, 화면이 답할 것이 「붙어 있다」
+             * 뿐이었다. 그런데 한 원본 안에서 흐름마다 신선도가 **크게 다르다**(실측: 재고 08-23 ·
+             * 계측 08-12 · 작업지시 05-10 · 공정·로트 04-15). 「붙어 있다」 하나로 뭉치면 넉 달 멈춘
+             * 흐름이 살아 있는 것으로 읽힌다.
+             *
+             * **계약에는 자리가 있다** — `LiveFeedCursor.since` 가 「그 흐름에서 마지막으로 본 시각
+             * (원본의 시각)」이고 `onCursor` 가 그것을 `TwinReference.liveCursor` 에 적는다. 없던 것은
+             * **화면으로 가는 문**이고, 그 문이 여기다.
+             *
+             * ★ **다만 지금은 비어 있다** — 실 저장값을 확인했다:
+             * `{"streams":{},"firstAttachedAt":"2026-03-25T…"}`. 즉 어댑터가 흐름별 커서를 적지 않는다.
+             * 그래서 이 문을 열어도 당장은 빈 목록이 나오고, **그것이 정직한 답이다**: 어댑터가 말하지
+             * 않는 것을 여기서 지어내지 않는다. 채우는 것은 어댑터의 몫이고 그쪽에 알렸다.
+             *
+             * 빈 목록과 「흐름이 없다」를 화면이 구별할 수 있어야 한다 — 이 값이 비면 그것은
+             * 「어댑터가 아직 말하지 않는다」이고 「원본에 흐름이 없다」가 아니다.
+             *
+             * `seen`(중복 걸러낸 행 id)은 내지 않는다 — 읽기 내부 상태이고 수천 개가 될 수 있다.
+             * 흐름 열쇠는 **어댑터가 정한다**(계약이 이름을 닫지 않는다). 그래서 이름을 번역하지 않고
+             * 그대로 낸다 — 화면이 모르는 이름을 만나면 그 이름을 보이는 것이 맞다.
+             */
+            streams: Object.entries((ref.liveCursor as any)?.streams ?? {})
+              .map(([stream, c]: [string, any]) => ({ stream, since: c?.since ?? null }))
+              /* 시각을 말하지 않는 흐름도 낸다 — 「모른다」와 「없다」는 다르고, 빼면 그 흐름이 사라진다. */
+              .sort((a, b) => String(b.since ?? '').localeCompare(String(a.since ?? ''))),
+            firstAttachedAt: (ref.liveCursor as any)?.firstAttachedAt ?? null
+          }
         : null,
       /*
        * **다시 읽을 수 있는가** — 이 트윈이 자기 원본을 기억하고 있나(`TwinInstance.origin`).