@things-factory/headless-twin 10.1.278 → 10.1.279

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

@@ -1,211 +0,0 @@
-import { nameIndex, namesFor } from './name-index.js'
-import { Arg, Ctx, Int, Query, Resolver } from 'type-graphql'
-
-import { ScalarObject, getRepository } from '@things-factory/shell'
-
-import { TwinInstance } from '../twin-instance/twin-instance.js'
-
-const { TWIN_RELATIONS, axisInfo } = require('@operato/ops-contract')
-
-/**
- * 재귀 전개 — **자기 축으로 돌아오는 선언을 따라간다.**
- *
- * ── 왜 자재가 자재를 품지 않는가 ───────────────────────────────────────────────
- * 다단 BOM 을 "자재 안에 자재" 로 적으면 같은 부품이 여러 완제품에 들어갈 때마다 복제되고,
- * 수량이 어디 붙는지도 애매해진다. 표준(ISA-95)이 택한 모양은 **자재와 레시피가 번갈아 나오는
- * 그래프**다: 완제품 ←산출— 레시피 —투입→ 부품들, 그리고 그 부품이 또 어느 레시피의 산출이면
- * 거기서 다시 내려간다. 우리 선언(`ops.rel.input`·`ops.rel.output`)이 이미 그 두 홉이다.
- *
- * ── 패턴을 코드가 알지 않는다 ──────────────────────────────────────────────────
- * "BOM 은 산출→투입" 이라고 적어 두면 그 순간 이 파일이 도메인을 알게 된다(ADR-0031 위반).
- * 대신 **선언 그래프에서 자기 축으로 돌아오는 두 홉 순환을 찾는다.** 자재만이 아니라 앞으로
- * 같은 모양을 갖는 어떤 축이든 그대로 펼쳐진다.
- *
- * ── 알리지 않고 고르지 않는다 ───────────────────────────────────────────────────────
- * 순환이 여럿이면 **아무거나 집지 않는다.** 후보를 돌려주고 부르는 쪽이 고르게 한다 — 한쪽을
- * 집으면 역전개(누가 나를 쓰나)를 전개(내가 무엇으로 되나)로 보여 주고도 아무도 모른다.
- */
-
-/** 자기 축으로 돌아오는 두 홉 — `axis ←down(via)— through —up(via)→ axis`. */
-interface WalkPattern {
-  /** 중간에 거치는 축(레시피 등). */
-  through: string
-  /** 나로 들어오는 홉 — "나를 이것의 산출로 삼는" 쪽. */
-  inVia: string
-  /** 거기서 다시 나가는 홉 — "그것이 투입하는" 쪽. */
-  outVia: string
-  inField: string
-  outField: string
-}
-
-/** 선언 그래프에서 이 축으로 돌아오는 순환들을 찾는다. */
-function patternsFor(axis: string): WalkPattern[] {
-  const toMe = TWIN_RELATIONS.filter((r: any) => r.target?.kind === 'axis' && r.target.axis === axis)
-  const out: WalkPattern[] = []
-  for (const a of toMe)
-    for (const b of toMe)
-      if (a !== b && a.from === b.from)
-        out.push({ through: a.from, inVia: a.via, outVia: b.via, inField: a.field, outField: b.field })
-  return out
-}
-
-const at = (o: any, path: string) => path.split('.').reduce((a: any, k: string) => (a == null ? undefined : a[k]), o)
-const idOf = (o: any): string | null => (typeof o === 'string' ? o : o?.id ?? o?.key ?? o?.gtin ?? null)
-
-/** `inputs[].material` — 배열을 지나는 선언 경로. 값과 **그 값을 담은 객체**를 함께 돌려준다(수량이 거기 있다). */
-function entriesAt(obj: any, field: string): { value: any; holder: any }[] {
-  let cur: { value: any; holder: any }[] = [{ value: obj, holder: obj }]
-  for (const seg of field.split('.')) {
-    const key = seg.endsWith('[]') ? seg.slice(0, -2) : seg
-    const next: { value: any; holder: any }[] = []
-    for (const c of cur) {
-      const v = c.value?.[key]
-      if (v == null) continue
-      if (Array.isArray(v)) for (const x of v) next.push({ value: x, holder: x })
-      else next.push({ value: v, holder: c.value })
-    }
-    cur = next
-  }
-  return cur
-}
-
-/** 이 홉이 실어 나르는 수량 — 선언에 있으면 쓰고, 없으면 **없다고 한다**(1 로 메우지 않는다). */
-function qtyOf(holder: any): number | null {
-  const q = holder?.qty ?? holder?.quantity
-  return typeof q === 'number' ? q : null
-}
-
-@Resolver()
-export class TwinModelTreeQuery {
-  @Query(returns => ScalarObject, {
-    nullable: true,
-    description:
-      'Recursively expand an item through a declared two-hop cycle (e.g. a multi-level BOM: product ←produced-by— recipe —consumes→ parts). The pattern is derived from the kernel relation declarations, never hardcoded. Reports the pattern used, any cycles found, and whether depth or item caps truncated the walk.'
-  })
-  async twinModelTree(
-    @Arg('instanceId') instanceId: string,
-    @Arg('axis') axis: string,
-    @Arg('itemId') itemId: string,
-    @Ctx() context: ResolverContext,
-    @Arg('inVia', { nullable: true }) inVia?: string,
-    @Arg('outVia', { nullable: true }) outVia?: string,
-    @Arg('maxDepth', type => Int, { nullable: true }) maxDepth?: number,
-    @Arg('maxItems', type => Int, { nullable: true }) maxItems?: number
-  ): Promise<any | null> {
-    const domainId = context.state.domain.id
-    const info = axisInfo(axis)
-    if (!info) throw new Error(`unknown concept axis: "${axis}" — the kernel catalog does not declare it`)
-
-    const inst = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-    if (!inst) return null
-
-    const all = patternsFor(axis)
-    if (!all.length) return { axis, itemId, patterns: [], items: [], edges: [], reason: 'no-recursive-relation' }
-
-
-    const chosen = inVia && outVia ? all.find(p => p.inVia === inVia && p.outVia === outVia) : all.length === 1 ? all[0] : undefined
-    if (!chosen)
-      /* 여럿인데 안 고르면 **아무것도 펼치지 않는다.** 한쪽을 집으면 역전개를 전개로 보여 주고도
-         아무도 모른다 — 방향이 뒤집힌 BOM 은 틀린 답이 아니라 반대의 답이다. */
-      return { axis, itemId, patterns: all, items: [], edges: [], reason: 'ambiguous-pattern' }
-
-    /*
-     * ── ★ **선언에 없는 축은 펼칠 것이 없다** (2026-08-24 실측으로 터짐) ────────
-     *
-     * 이 전개는 **트윈 모델의 선언**을 읽는다(`axisInfo(...).path` 로 모델 안을 찾아 들어간다). 그런데
-     * 커널 카탈로그의 축 중 셋은 **선언되는 것이 아니라 일어나는 것**이다 — `orders`·`tasks`·`items`
-     * 는 사건이 만들고 끝나면 사라진다. 모델이 그 목록을 가질 수 없으므로 `path` 가 비어 있다.
-     *
-     * 그래서 그런 축을 지나려 하면 `at(model, undefined)` 에서 터졌다:
-     *
-     *   Cannot read properties of undefined (reading 'split')
-     *
-     * ★ **터진 것은 요청한 축이 아니라 「거쳐 가는 축」이다.** `locations` 를 물으면 그 순환이
-     * `tasks` 를 거치는데(작업이 `from`·`at` 으로 자리를 두 번 가리킨다) 그 `tasks` 에 경로가 없다.
-     * 그래서 요청한 축만 지켜서는 막히지 않는다 — 둘 다 본다.
-     *
-     * ── 터지지 않게 하는 것만으로는 모자라다 ──────────────────────────────────
-     * 빈 트리를 돌려주면 화면이 **「이어진 것이 없다」**로 읽는다. 그것은 거짓이다 — 작업은 자리를
-     * 가리키고 있고, 다만 **이 질의가 그것을 아는 곳이 아니다**(그 관계는 상태와 저널이 안다).
-     * 그래서 이유를 말한다. 왜 못 하는지 말하지 않는 빈 화면이 이 저장소가 반복해 고친 결함이다.
-     */
-    if (!info.path || !axisInfo(chosen.through)?.path)
-      return { axis, itemId, patterns: all, items: [], edges: [], reason: 'not-declared-in-model' }
-
-    const model = inst.model ?? {}
-    const throughInfo = axisInfo(chosen.through)
-    const listOf = (i: any) => {
-      const raw = i ? at(model, i.path) : undefined
-      return Array.isArray(raw) ? raw : raw ? [raw] : []
-    }
-    const throughAll = listOf(throughInfo)
-    const mineAll = listOf(info)
-    const mineIds = new Set(mineAll.map(idOf).filter(Boolean) as string[])
-
-    const depthCap = Math.min(Math.max(maxDepth ?? 6, 1), 12)
-    const itemCap = Math.min(Math.max(maxItems ?? 200, 1), 2000)
-
-    const items: any[] = [{ id: itemId, axis, depth: 0, qty: 1, known: mineIds.has(itemId) }]
-    const edges: any[] = []
-    const seen = new Set<string>([itemId])
-    const cycles: string[] = []
-    let depthTruncated = false
-    let itemTruncated = false
-
-    /* 너비 우선 — 깊이 상한에서 끊기면 **얕은 층은 온전히** 남는다(깊이 우선이면 한 가지만 깊게 파고 끊긴다). */
-    let frontier: { id: string; depth: number; qty: number | null }[] = [{ id: itemId, depth: 0, qty: 1 }]
-    while (frontier.length) {
-      const nextFrontier: typeof frontier = []
-      for (const cur of frontier) {
-        if (cur.depth >= depthCap) { depthTruncated = true; continue }
-        /* 나를 만들어 내는 중간 항목들(레시피)을 찾는다 — 선언된 홉을 따라. */
-        for (const t of throughAll) {
-          const producesMe = entriesAt(t, chosen.inField).some(e => String(idOf(e.value) ?? e.value) === cur.id)
-          if (!producesMe) continue
-          for (const e of entriesAt(t, chosen.outField)) {
-            const childId = String(idOf(e.value) ?? e.value)
-            const step = qtyOf(e.holder)
-            /* 수량을 모르면 **곱하지 않는다.** 1 로 메우면 "1개 필요" 라는 사실 주장이 되고,
-               윗단에서 곱해진 값이 전부 거짓이 된다. */
-            const qty = cur.qty != null && step != null ? cur.qty * step : null
-            edges.push({ from: cur.id, to: childId, through: idOf(t), depth: cur.depth + 1, step, qty })
-
-            if (seen.has(childId)) {
-              /* 이미 지난 항목으로 돌아왔다 — 사이클이거나 공유 부품이다. 어느 쪽이든 **다시 파지
-                 않고 말한다.** 파고 들어가면 돌아 나오지 못한다. */
-              if (edges.some(x => x.to === cur.id && x.from === childId)) cycles.push(`${cur.id} ↔ ${childId}`)
-              continue
-            }
-            if (items.length >= itemCap) { itemTruncated = true; continue }
-            seen.add(childId)
-            items.push({ id: childId, axis, depth: cur.depth + 1, qty, known: mineIds.has(childId) })
-            nextFrontier.push({ id: childId, depth: cur.depth + 1, qty })
-          }
-        }
-      }
-      frontier = nextFrontier
-    }
-
-    return {
-      axis,
-      itemId,
-      /* 어떤 순환을 따라 펼쳤는지 **밝힌다** — 방향이 뒤집힌 전개는 틀린 답이 아니라 반대의 답이라
-         화면만 보고는 구별되지 않는다. */
-      pattern: chosen,
-      patterns: all,
-      items,
-      edges,
-      /* 수량을 하나라도 모르면 아래 합계가 성립하지 않는다는 사실을 그대로 낸다. */
-      /*
-       * **이름을 함께 낸다** (2026-08-22). 나무의 줄이 id 만 보이면 사용자는 그 노드가 무엇인지 알 수
-       * 없다 — 사용자의 말: 「각 노드의 식별자가 반복되어서 이해가 어렵다. 식별자와 이름이 보이면.」
-       * 목록·항목 화면이 쓰는 것과 **같은 표**를 쓴다(`name-index`) — 두 벌이면 한쪽만 고쳐진다.
-       */
-      names: namesFor(items, nameIndex(inst.model ?? {})),
-      qtyIncomplete: edges.some(e => e.step == null),
-      cycles: [...new Set(cycles)],
-      truncated: { depth: depthTruncated, items: itemTruncated, depthCap, itemCap },
-      basis: 'document'
-    }
-  }
-}

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

@@ -1,157 +0,0 @@
-import { CreateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { ObjectType, Field, ID, Int } from 'type-graphql'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-
-import { TwinInstance } from '../twin-instance/twin-instance.js'
-
-/*
- * TwinOperation — 이 트윈이 반영하는 **공정 명세**. ISA-95 `OperationsSegment`.
- * 이 현장에서 각 작업이 **어디서·무엇으로·얼마나 걸리나**(선언값).
- *
- * ── 왜 이 표가 인스펙션의 중심인가 ──────────────────────────────────────────
- * 인스펙션 화면의 존재 이유는 `선언 | 관측` 두 열이고(`plans/twin-inspection.md` §2.4),
- * 그 첫 열이 여기서 온다. 둘째 열은 저널에서 계산된다(`kpi-fold.workTime`).
- * 실적은 보이는데 기준이 안 보이면 "절단이 5분 걸렸다" 를 보고도 빠른지 느린지 알 수 없다.
- *
- * 자리·설비와 같은 규율 — **원본에서 온 캐시**, `sourceRef`·`ingestedAt` 필수,
- * 쓰기 경로는 인제스트 하나(`twin-location.ts` 머리말).
- */
-@Entity({ name: 'twin_operations' })
-@Index('ix_twin_operation_0', (e: TwinOperation) => [e.domain, e.instance, e.operationKey], { unique: true })
-@ObjectType({ description: 'An operation spec reflected into the twin (ISA-95 OperationsSegment): where it runs, with what, and how long the source says it takes.' })
-export class TwinOperation {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true, description: 'Owning tenant domain.' })
-  domain?: Domain
-
-  @RelationId((e: TwinOperation) => e.domain)
-  domainId?: string
-
-  @ManyToOne(type => TwinInstance, { onDelete: 'CASCADE' })
-  @Field(type => TwinInstance, { nullable: true, description: 'Owning twin instance.' })
-  instance?: TwinInstance
-
-  @RelationId((e: TwinOperation) => e.instance)
-  instanceRowId?: string
-
-  /** 커널 계약의 `OperationDef.key` 그대로. 라우트의 단계가 이 키로 가리킨다. */
-  @Column()
-  @Field({ description: 'Operation key as declared by the source (kernel OperationDef.key). Route steps reference this.' })
-  operationKey: string
-
-  /**
-   * **사람이 부르는 이름** — 프레임워크 엔티티 규약의 `name`/`description`.
-   *
-   * ── 왜 이것이 빠져 있었고, 무엇이 망가졌나 ────────────────────────────────────
-   * 투영이 마스터의 `name` 을 버리고 있었다. 그래서 행에는 id 만 남고, 화면은 이름을 만들 재료가
-   * 없어 `cut-station` 을 그대로 찍었다 — 그 결함이 목록·표·관계 그림마다 따로 나타나서 표면을
-   * 하나씩 고치게 만들었다. 표면의 문제가 아니라 **행에 이름이 없던 문제**다.
-   *
-   * 원본이 이름을 말하지 않으면 비운다(id 를 이름으로 베끼지 않는다 — 그러면 "이름이 있다" 는
-   * 거짓이 되고, 화면이 이름 없음을 알아볼 수 없게 된다).
-   */
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Human name as declared by the source. Empty when the source does not name it (never copied from the id).' })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Longer description when the source provides one.' })
-  description?: string
-
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: "Intent: 'transport' | 'process' | 'dwell'." })
-  intent?: string
-
-  /*
-   * 어디서·무엇으로 — 자리·설비의 **항목이 아니라 타입**을 가리킨다("절단은 cut-station 에서 수행된다").
-   * 그래서 FK 가 아니다. 화면은 이것을 "그 타입의 자리·설비 목록" 으로 푼다(관계 선언의 `type` 대상).
-   */
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Location type this operation runs at (a catalog type key, not an item reference).' })
-  locationType?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Resource type that performs it (a catalog type key, not an item reference).' })
-  resourceType?: string
-
-  /**
-   * 소요시간 — **ISO 8601 기간 문자열이 정본**(`PT1H10M`).
-   *
-   * 분으로 저장하면 `PT1H10M30S` 의 초가 사라지고 그 손실은 들어온 것이 없다. 사람이 읽을 분은
-   * 화면이 곁들여 보여 주고, 못 읽는 값은 `—` 로 낸다(0 으로 채우면 "즉시 끝나는 공정" 이라는 거짓).
-   */
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Declared duration as an ISO 8601 period (e.g. PT1H10M). The string is canonical — storing minutes would silently drop seconds.' })
-  duration?: string
-
-  /**
-   * 변동성·파라미터(수율·셋업)는 형이 도메인마다 달라 **원형 그대로** 싣는다.
-   * 여기를 컬럼으로 펴려면 커널이 그 형을 먼저 고정해야 한다 — 아직 아니다.
-   */
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true, description: 'Declared variability (distribution/min/max/mode) as given by the source.' })
-  variability?: any
-
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true, description: 'Declared parameters (yield, setup duration…) as given by the source.' })
-  parameters?: any
-
-  /**
-   * **네 자원 명세 — 선언한 것만 제약이 된다.**
-   *
-   * ISA-95 는 한 공정이 무엇을 필요로 하는지를 넷으로 말한다: 설비(`resourceType`)·인원·자산·자재.
-   * 커널도 그 넷을 그대로 본다 — 선언이 있으면 잡아야 작업이 시작되고, 없으면 그 자원을 보지 않는다.
-   *
-   * 이 셋이 투영에서 **떨어져 있었다.** 그래서 조회 화면의 "원본이 말한 값" 열에 넷 중 하나만
-   * 나왔고, 사람이 필요한 공정을 보고도 **사람이 필요 없다고 결론 내게** 되어 있었다. 원본이 말한
-   * 것을 화면이 말하지 않으면 그 화면은 원본을 반영하는 것이 아니다.
-   *
-   * 모양은 커널 계약 그대로 싣는다 — 인제스트 경계에서 모양을 바꾸면 그 자리에서 방언이 생긴다.
-   */
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true, description: 'Personnel this operation requires (ISA-95 PersonnelSpecification): class + quantity. Absent means the operation runs without people.' })
-  personnelSpecification?: any
-
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true, description: 'Physical assets this operation requires (ISA-95 PhysicalAssetSpecification). Absent means no asset constraint — an empty pallet is never the reason a job waits.' })
-  physicalAssetSpecification?: any
-
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true, description: 'Materials this operation consumes or produces (ISA-95 MaterialSpecification). Absent means material shortage never shows up in the forecast for this step.' })
-  materialSpecification?: any
-
-  /** 라우트 안에서의 순서 — 라우트가 이 공정을 몇 번째로 부르나(라우트 표가 서면 그리로 옮긴다). */
-  @Column({ type: 'int', nullable: true })
-  @Field(type => Int, { nullable: true, description: 'Sequence within its route, when the source declares one.' })
-  seq?: number
-
-  /* ── 캐시라는 사실을 구조로 (ADR-0032-D) ── */
-  @Column()
-  @Field({ description: 'Which reference (source system) this row came from. Required.' })
-  sourceRef: string
-
-  /*
-   * **타입 이름을 적지 않는다** (2026-08-19 Postgres 부팅 실패로 고침).
-   *
-   * `datetime` 은 sqlite·MySQL 의 이름이고 Postgres 는 `timestamp` 만 안다 — 거꾸로 `timestamp` 는
-   * sqlite 가 모른다. **다섯 드라이버에 다 통하는 이름이 없다.** 그래서 이름 고르는 일을 TypeORM 에
-   * 맡긴다(`emitDecoratorMetadata` 가 켜져 있어 `Date` 에서 드라이버별 타입을 고른다).
-   */
-  @Column()
-  @Field({ description: 'When this row was projected from the source.' })
-  ingestedAt: Date
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-}

package/server/service/twin-readiness/index.ts

@@ -1,3 +0,0 @@
-import { TwinReadinessQuery } from './twin-readiness-query.js'
-
-export const resolvers = [TwinReadinessQuery]

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

@@ -1,96 +0,0 @@
-import { Arg, Ctx, Query, Resolver } from 'type-graphql'
-
-import { getRepository, ScalarObject } from '@things-factory/shell'
-
-import { TwinEngine } from '../../engine/index.js'
-import { assessSuite, SUITE_SPEC, type SuiteFacts } from '../../engine/integration-runner.js'
-import { readSpecCoverage } from '../../engine/spec-coverage.js'
-import { capabilitiesOf, getAdapter } from '../reference/reference-adapter.js'
-import { TwinEvent } from '../twin-event/twin-event.js'
-import { anyJournalRow, countUpTo } from '../twin-event/journal-count.js'
-import { TwinInstance } from '../twin-instance/twin-instance.js'
-import { TwinReference } from '../reference/twin-reference.js'
-
-/*
- * 도입 단계 — **「이 트윈은 어디까지 증명됐나」.**
- *
- * `twinIngestHealth` 와 묻는 것이 다르다: 그쪽은 「지금 현장과 맞춰지고 있나」(피드의 건강)이고,
- * 여기는 「구조·라이브·예측·폐루프 중 어디까지 **증거로** 섰나」다. 체크리스트가 아니라 판정이므로
- * 사람이 체크해서 초록으로 만들 수 없다.
- *
- * **접속 프로브는 여기서 돌리지 않는다.** 조회마다 고객 시스템을 두드리면 화면을 열 때마다 남의
- * 운영계에 부하가 간다. 그래서 `connectOk` 는 `null`(안 돌렸다)이고, 계획의 첫 칸이 접속 확인이 된다.
- */
-@Resolver()
-export class TwinReadinessQuery {
-  @Query(returns => ScalarObject, {
-    nullable: true,
-    description:
-      'Which adoption stage this twin has actually reached, judged from evidence rather than a checklist: structure, live, forecast, closed-loop. Each stage reports what blocks it and which signals could not be measured at all — an unmeasured signal never counts as achieved, so a half-run suite cannot claim green. Probes that do not apply to this twin (live probes on a simulation, mapping-warning probes on a template-built twin) come back as notApplicable with a reason, which is neither a pass nor a gap. `forbiddenClaims` lists the claims that must not be made yet (realtime, prediction, automatic control). The connection probe is not run here because a read query should not hit the source system on every page load, so it appears in `planned` as the next step to take. Null if the instance is not in the current domain.'
-  })
-  async twinAdoptionPath(@Arg('instanceId') instanceId: string, @Ctx() context: ResolverContext): Promise<any> {
-    const domainId = context.state.domain.id
-    if (!TwinEngine.owns(domainId, instanceId) && !(await TwinEngine.ownsRegistered(domainId, instanceId))) return null
-
-    const inst = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-    if (!inst) return null
-    const ref = await getRepository(TwinReference)
-      .findOne({ where: { domain: { id: domainId }, source: instanceId } })
-      .catch(() => null)
-
-    const mode = TwinEngine.modeOf(domainId, instanceId)
-    const snapshot = TwinEngine.owns(domainId, instanceId) ? TwinEngine.snapshot(domainId, instanceId) : undefined
-    const events = getRepository(TwinEvent)
-
-    /*
-     * 저널에서 센다 — **재시작에도 남는 자리**다. 인메모리 계기로 세면 재기동마다 0 이 되고, 그 0 이
-     * 「세었는데 반출이 없었다」로 읽혀 라이브 단계를 거짓으로 막는다.
-     *
-     * `action` 승격 전에 기록된 행은 세어지지 않는다. 그래서 반출이 **한 건도 없고** 승격 이후 유입도
-     * 없으면 `null`(모른다)로 낸다 — 옛 저널을 「반출 0건」으로 단정하지 않는다.
-     */
-    /*
-     * **상한까지만 센다** (2026-08-22 실측). 예전에는 넷을 전부 세었고, 저널 358만 행인 트윈에서 한 번이
-     * 5.32초라 이 화면 하나가 20초를 썼다. 판정에 쓰이는 것은 문턱(≥1)이므로 상한까지의 수로 충분하고,
-     * 승격 여부는 **한 건만 찾으면** 답이 난다(수가 필요 없다).
-     */
-    const scope = { domain: { id: domainId }, instanceId }
-    const journal = await countUpTo(events, scope)
-    const removalCount = await countUpTo(events, { ...scope, action: 'DELETE' })
-    const journalTotal = journal.count
-    const removals = removalCount.count
-    const anyPromoted =
-      removals > 0 ||
-      (await anyJournalRow(events, { ...scope, action: 'OBSERVE' })) ||
-      (await anyJournalRow(events, { ...scope, action: 'ADD' }))
-
-    const modelLocations = Array.isArray((inst.model as any)?.locations) ? (inst.model as any).locations.length : null
-
-    const facts: SuiteFacts = {
-      subject: mode === 'live' ? 'live' : mode === 'sim' ? 'sim' : 'unknown',
-      fromReference: !!ref,
-      adapterCapabilities: ref?.adapterType ? capabilitiesOf(getAdapter(ref.adapterType)) : [],
-      connectOk: null, // 조회에서 남의 운영계를 두드리지 않는다
-      /* 이 레퍼런스가 트윈을 세운 사이트 수 — 발견의 결과다(발견 자체를 다시 돌리지 않는다). */
-      siteCount: ref ? ((ref.scopeSpec as any)?.produced?.length ?? null) : null,
-      locationCount: snapshot?.locations?.length ?? modelLocations,
-      itemCount: snapshot?.items?.length ?? null,
-      lastWarningCount: ref?.lastWarningCount ?? null,
-      journalTotal,
-      /* 승격 이후 유입이 하나도 없으면 세지 못한 것이다 — 0 으로 단정하지 않는다. */
-      removalsJournaled: anyPromoted ? removals : null,
-      specCoverage: (() => {
-        const c: any = snapshot ? readSpecCoverage(snapshot) : null
-        if (!c?.operations?.length) return null
-        const total = c.operations.length
-        const declared = c.operations.filter((o: any) => o.duration === 'declared' || o.duration === 'measured').length
-        return { declared, total }
-      })(),
-      forecastRan: null, // 예측 실행 이력을 남기는 자리가 아직 없다 — 모른다고 말한다
-      feed: 'unknown'
-    }
-
-    const assessment = assessSuite(facts)
-    return { instanceId, ...assessment, spec: SUITE_SPEC, facts }
-  }
-}

package/server/service/twin-space/area-resolver.ts

@@ -1,75 +0,0 @@
-/*
- * What an area id is — the host's answer for `external: 'space.area'`.
- *
- * The contract declares a location's parent as another location or, when no location has that id, an area of the
- * space (`axis-or-external`), and says the host resolves the external half. Nothing registered a resolver, so on
- * 2026-09-18 every location in the running twin showed its parent as "no component can resolve this relation" —
- * the areas were in this package's own table all along.
- *
- * The lookup is (domain, space, areaId), the table's own unique key: an `areaId` is unique inside a space, so a
- * tenant can hold the same id in two spaces. The space comes from the twin the relation belongs to, which is why
- * `resolve` is given the instance (external-resolver.ts `ExternalResolveContext`). Looking up by tenant alone
- * would answer another space's name as this location's parent.
- *
- * No `href`: the screen that opens an area belongs to the product app, and putting its route here would fix a
- * product screen's address in this package. With no href the screen shows the name and makes no link — that is
- * what the field is for (no dead links). A route is registered the day a screen needs it.
- */
-import { getRepository } from '@things-factory/shell'
-import { In } from 'typeorm'
-
-import { registerExternalResolver, type ExternalRef, type ExternalResolveContext } from '../twin-model/external-resolver.js'
-import { TwinInstance } from '../twin-instance/twin-instance.js'
-import { TwinSpace } from './twin-space.js'
-import { TwinArea } from './twin-area.js'
-
-/** The contract's word for this target. Must match `target.entity` or it attaches to no relation. */
-export const SPACE_AREA_ENTITY = 'space.area'
-
-export async function resolveAreas(
-  domainId: string,
-  ids: readonly string[],
-  context: ExternalResolveContext,
-  warn?: (msg: string) => void
-): Promise<ExternalRef[]> {
-  const wanted = [...new Set(ids.map(String).filter(Boolean))]
-  if (!wanted.length) return []
-
-  /* Which space is this twin in? A twin with no space has no areas to point at — every id is then missing. */
-  const inst = await getRepository(TwinInstance).findOne({
-    where: { domain: { id: domainId } as any, instanceId: context.instanceId }
-  })
-  const spaceId = inst?.spaceId
-  if (!spaceId) {
-    warn?.(`[area-resolver] twin "${context.instanceId}" is in no space — its parent ids cannot be areas`)
-    return wanted.map(id => ({ id, missing: true }))
-  }
-  const space = await getRepository(TwinSpace).findOne({ where: { domain: { id: domainId } as any, spaceId } })
-  if (!space) {
-    warn?.(`[area-resolver] space "${spaceId}" of twin "${context.instanceId}" is not in this tenant`)
-    return wanted.map(id => ({ id, missing: true }))
-  }
-
-  const rows = await getRepository(TwinArea).find({
-    where: { domain: { id: domainId } as any, space: { id: space.id } as any, areaId: In(wanted) }
-  })
-  const byId = new Map(rows.map(r => [r.areaId, r]))
-
-  /* An id that is in no area of this space is said to be missing — it is not dropped from the answer. */
-  return wanted.map(id => {
-    const area = byId.get(id)
-    if (!area) return { id, missing: true }
-    return area.name ? { id, name: area.name } : { id }
-  })
-}
-
-/** Registered at boot, once — the same shape as the reference link resolver. */
-export function installAreaResolver(warn?: (msg: string) => void): void {
-  registerExternalResolver(
-    {
-      entity: SPACE_AREA_ENTITY,
-      resolve: (domainId, ids, context) => resolveAreas(domainId, ids, context, warn)
-    },
-    warn
-  )
-}

package/server/service/twin-space/index.ts

@@ -1,8 +0,0 @@
-import { TwinSpace } from './twin-space.js'
-import { TwinSpaceRepresentation } from './twin-space-representation.js'
-import { TwinSpaceArea } from './twin-space-area.js'
-import { TwinArea } from './twin-area.js'
-import { TwinSpaceResolver } from './twin-space-resolver.js'
-
-export const entities = [TwinSpace, TwinSpaceRepresentation, TwinSpaceArea, TwinArea]
-export const resolvers = [TwinSpaceResolver]