@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/connector-capability-declaration.test.ts

@@ -1,195 +0,0 @@
-/*
- * ★ 구현했는데 선언하지 않은 능력을 아무도 말해 주지 않았다.
- *
- * ── 무엇이 났나 (2026-08-25) ────────────────────────────────────────────────
- * 능력 판정은 **한 방향만** 본다. 선언했는데 구현이 없는 것은 걸러 내고, 구현했는데 선언이 없는 것은
- * 들어온 것이 없다. 그래서 태양광 발전소를 붙이던 사람이 이렇게 막혔다.
- *
- *   커넥터가 openLiveFeed 를 구현했다 · capabilities: ['live'] 를 잊었다
- *   → 연결 화면이 「이 원본은 라이브를 못 낸다」로 읽는다
- *   → 재기동 정책을 정할 수 없어 트윈 생성이 거절된다
- *   → 화면에 보이는 것은 「재기동 정책이 없습니다」뿐이다
- *
- * 원인을 찾는 데 코드를 뒤져야 했다. 지금 저장소에 같은 상태인 커넥터가 일곱이다.
- *
- * ── 막지 않고 알린다 ────────────────────────────────────────────────────────
- * 등록에서 던지면 커넥터 하나 때문에 호스트가 못 뜬다. 만들다 만 커넥터를 들고 있는 사람이 아무것도
- * 못 하게 된다. 이 어긋남은 고칠 수 있는 것이지 위험한 것이 아니다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-/* `twinWarn` 은 `console.warn` 으로 나간다 — 모듈을 바꿔치지 않고 그 자리에서 받는다. */
-const warnings: string[] = []
-const originalWarn = console.warn
-console.warn = (...args: unknown[]) => {
-  warnings.push(args.join(' '))
-}
-process.on('exit', () => (console.warn = originalWarn))
-
-const { registerAdapterType, capabilitiesOf } = await import('../server/service/reference/reference-adapter.js')
-
-const adapter = (over: Record<string, unknown> = {}) =>
-  ({
-    type: `probe-${Math.round(performance.now() * 1000)}-${warnings.length}`,
-    async fetchMaster() {
-      return {} as any
-    },
-    ...over
-  }) as any
-
-test('★ 라이브를 구현하고 선언하지 않으면 말해 준다 — 이것이 없어서 화면이 다른 말을 했다', () => {
-  const before = warnings.length
-  const a = adapter({ openLiveFeed: () => () => {} })
-  registerAdapterType(a)
-  const said = warnings.slice(before).join('\n')
-  assert.ok(said.includes(a.type), '어느 커넥터인지 말한다')
-  assert.ok(said.includes('live'), '무엇이 빠졌는지 말한다')
-  assert.ok(said.includes('capabilities'), '무엇을 하면 되는지 말한다')
-  /* 그리고 지금 화면이 어떻게 읽는지도 말한다 — 사람이 겪은 증상과 이어져야 원인으로 읽힌다. */
-  assert.ok(/live twin cannot be created/.test(said))
-})
-
-test('★ 구동을 구현하고 선언하지 않아도 말해 준다 — 같은 규율이다', () => {
-  const before = warnings.length
-  const a = adapter({ control: async () => ({ ok: true }) })
-  registerAdapterType(a)
-  assert.ok(warnings.slice(before).join('\n').includes('control'))
-})
-
-test('★ 조치를 구현하고 선언하지 않아도 말해 준다 — 그 이름이 없어서 오늘 하루가 갔다', () => {
-  /*
-   * 이 자리에 `actuate` 가 없었다. 능력 축이 `live`·`control` 둘뿐이라 커넥터는 조치를 **선언할
-   * 방법이 없었고**, 등록 검사도 그것을 물을 수 없었다. MES 커넥터는 그 사이에 `actuate` 를 다
-   * 만들어 두었는데, 넘기는 자리는 「구현이 없습니다」로 답했다.
-   *
-   * 그 문장이 그럴듯해서 설계 문서와 다른 레인에까지 사실로 옮겨졌다. 오류가 아니라 **정직해 보이는
-   * 거절**이 원인이었다.
-   */
-  const before = warnings.length
-  const a = adapter({ actuate: async () => ({ ok: true }) })
-  registerAdapterType(a)
-
-  const said = warnings.slice(before).join('\n')
-  assert.ok(said.includes('actuate'), '무엇이 빠졌는지 말한다')
-  assert.ok(said.includes(a.type), '어느 커넥터인지 말한다')
-})
-
-test('여럿이 어긋나면 다 말한다 — 하나만 말하면 고친 뒤 또 막힌다', () => {
-  const before = warnings.length
-  const a = adapter({
-    openLiveFeed: () => () => {},
-    control: async () => ({ ok: true }),
-    actuate: async () => ({ ok: true })
-  })
-  registerAdapterType(a)
-
-  const said = warnings.slice(before).join('\n')
-  for (const name of ['live', 'control', 'actuate']) {
-    assert.ok(said.includes(name), `${name} 를 말하지 않았다`)
-  }
-})
-
-test('★ 능력 이름이 늘면 검사도 함께 는다 — 표 하나에서 돈다', () => {
-  /*
-   * 예전에는 검사할 능력 셋이 코드 안에 손으로 적혀 있었다(`['live','control']`). 새 능력을 넣을 때
-   * 판정에는 넣고 검사에는 잊으면, **구현했는데 선언 안 한 것을 아무도 말해 주지 않는다** — 오늘 그
-   * 상태였다.
-   *
-   * 지금은 능력↔메서드 표 하나에서 돈다. 이 시험은 그 표가 실제로 셋을 다 덮는지 본다 — 넷째 능력을
-   * 넣고 표에 안 적으면 여기서 걸린다.
-   */
-  const cases: [string, Record<string, unknown>][] = [
-    ['live', { openLiveFeed: () => () => {} }],
-    ['control', { control: async () => ({ ok: true }) }],
-    ['actuate', { actuate: async () => ({ ok: true }) }]
-  ]
-
-  for (const [name, impl] of cases) {
-    const before = warnings.length
-    registerAdapterType(adapter(impl))
-    assert.ok(
-      warnings.slice(before).join('\n').includes(name),
-      `${name} 를 구현하고 선언하지 않았는데 아무 말도 하지 않았다 — 검사 표에 그 이름이 없다`
-    )
-  }
-})
-
-test('선언과 구현이 맞으면 아무 말도 하지 않는다 — 소음이 되면 아무도 읽지 않는다', () => {
-  const before = warnings.length
-  registerAdapterType(adapter({ openLiveFeed: () => () => {}, capabilities: ['live'] }))
-  registerAdapterType(adapter({}))
-  assert.equal(warnings.length, before)
-})
-
-test('★ 선언했는데 증명이 없는 쪽도 말해 준다 — 걸러 내고 조용하면 아무도 못 듣는다', () => {
-  /*
-   * 2026-09-16 에 뒤집었다(ADR-0036 ③ 개정). 이 시험은 그전까지 「여기서 두 번 말하지 않는다」였다 —
-   * 판정이 걸러 내니 경고는 반대 방향만 보면 된다는 읽기였다.
-   *
-   * 그런데 걸러 낸 사실을 **아무도 듣지 못한다.** 커넥터를 만든 사람은 선언했으니 된 줄 알고, 화면은
-   * 못 한다고 말하고, 그 사이에 오류가 하나도 없다. 한 방향만 보는 검사는 **없는 것을 있다고**
-   * (선언만 믿을 때) 또는 **있는 것을 없다고**(증명 형태가 하나뿐일 때) 말하게 된다. 둘 다 조용하다.
-   */
-  const before = warnings.length
-  const a = adapter({ capabilities: ['live'] })
-  registerAdapterType(a)
-
-  const said = warnings.slice(before).join('\n')
-  assert.ok(said.includes(a.type), '어느 커넥터인지 말한다')
-  assert.ok(said.includes('live'), '무엇이 증명되지 않았는지 말한다')
-  assert.ok(said.includes('openLiveFeed') && said.includes('handleInbound'), '무엇을 만들면 되는지 둘 다 말한다')
-  assert.deepEqual(capabilitiesOf(a), [], '판정은 그대로 걸러 낸다 — 경고는 그 사실을 들리게 할 뿐이다')
-})
-
-test('★ 밀어 넣는 원본도 라이브다 — handleInbound 가 live 를 증명한다', () => {
-  /*
-   * `operato-plant` 은 outbox 가 웹훅으로 밀어 넣는 쪽이라 `openLiveFeed` 가 없다. 증명을 그 하나로
-   * 두었을 때 **실 생산 사실을 나르는 유일한 커넥터가 판정에서 live 가 아니었다.**
-   *
-   * 당김이냐 밀림이냐는 상대 시스템의 성질이지 우리 능력의 종류가 아니다.
-   */
-  const pushed = adapter({ capabilities: ['live'], handleInbound: () => ({ records: [] }) })
-  const pulled = adapter({ capabilities: ['live'], openLiveFeed: () => () => {} })
-
-  assert.deepEqual(capabilitiesOf(pushed), ['live'], '밀어 넣는 쪽이 live 로 서지 않는다')
-  assert.deepEqual(capabilitiesOf(pulled), ['live'], '당겨 오는 쪽도 그대로')
-})
-
-test('★ handleInbound 만 있고 선언을 잊어도 말해 준다 — 증명이 둘이면 경고도 둘을 봐야 한다', () => {
-  const before = warnings.length
-  const a = adapter({ handleInbound: () => ({ records: [] }) })
-  registerAdapterType(a)
-
-  const said = warnings.slice(before).join('\n')
-  assert.ok(said.includes('live'), 'handleInbound 를 live 의 증명으로 세지 않는다')
-  assert.ok(said.includes(a.type))
-})
-
-test('★ 등록을 막지 않는다 — 커넥터 하나 때문에 호스트가 못 뜨면 안 된다', () => {
-  const a = adapter({ openLiveFeed: () => () => {} })
-  assert.doesNotThrow(() => registerAdapterType(a))
-  /* 등록은 되었고, 다만 그 능력은 선언되지 않았으므로 판정에서 빠진다 — 그 사실이 경고와 짝이다. */
-  assert.deepEqual(capabilitiesOf(a), [])
-})
-
-test('★ 어댑터 목록이 내보내는 능력은 판정값이다 — 선언 원본이 아니다', async () => {
-  /*
-   * 이것이 없어서 `capabilitiesOf` 의 판정값을 **읽는 자리가 하나도 없었다.** `listAdapters()` 가
-   * `a.capabilities` 를 그대로 냈고, 연결 화면은 그것을 읽었다. 선언을 믿지 않으려고 만든 문을
-   * 아무도 지나지 않은 셈이다 — 구현 없이 능력을 적기만 하면 화면에서 가능한 것으로 보였다.
-   */
-  const { listAdapters } = await import('../server/service/reference/reference-adapter.js')
-
-  const lying = adapter({ capabilities: ['live', 'actuate'] })
-  const honest = adapter({ capabilities: ['live'], handleInbound: () => ({ records: [] }) })
-  registerAdapterType(lying)
-  registerAdapterType(honest)
-
-  const listed = listAdapters()
-  const byType = new Map(listed.map(one => [one.type, one.capabilities ?? []]))
-
-  assert.ok(listed.length > 0, '목록이 비어 있으면 이 시험이 아무것도 안 잰다')
-  assert.deepEqual(byType.get(lying.type), [], '증명 없는 선언이 목록에 그대로 나간다')
-  assert.deepEqual(byType.get(honest.type), ['live'], '증명된 능력은 그대로 나간다')
-})

package/test/contract-layer-guard.test.ts

@@ -1,48 +0,0 @@
-/*
- * **층이 이름만 남지 않게 한다** — 계약은 계약 패키지에서 온다.
- *
- * ── 왜 있나 (2026-08-30) ──────────────────────────────────────────────────
- * 어휘와 판별 함수를 `@operato/ops-contract` 로 갈라냈다. 사실을 만드는 쪽(MES · WMS · 커넥터)이
- * 엔진을 의존하지 않게 하기 위해서다.
- *
- * ── 처음에는 커널이 계약을 다시 내보냈다 ──────────────────────────────────
- * 이유는 「이 저장소를 한 줄도 안 고쳐도 되게」였다. 그것은 **관리 편의**이지 구조의 근거가 아니다.
- * 그렇게 두면 같은 이름을 두 경로로 가져올 수 있고, 새 코드가 편한 쪽을 쓰면 계약이 커널 뒤에 숨는다.
- *
- * 그때는 이 파일에 **세는 시험**이 있었다 — 커널 경로로 가져오는 자리가 늘지 않는지 보는 것이다.
- * 세는 시험은 층이 깨졌다는 것을 인정하고 빚을 재는 도구다. 재export 를 걷으면서 그 시험도 없앴다.
- *
- * 지금 남은 것은 **사실을 확인하는 것**뿐이다. 커널이 계약을 내보내지 않으므로 잘못된 경로는 아예
- * 컴파일되지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import * as contract from '@operato/ops-contract'
-import * as kernel from '@operato/twin-kernel'
-
-test('★ 계약 패키지가 어휘를 내보낸다', () => {
-  const names = Object.keys(contract)
-  assert.ok(names.length > 100, `계약이 내보내는 이름이 ${names.length}개뿐이다 — 설치가 잘못됐다`)
-  for (const must of ['isEnergyRecord', 'ENERGY_EVENT', 'effectivityAt', 'ingestMasterData', 'procedureViolations']) {
-    assert.ok(names.includes(must), `${must} 가 계약에 없다`)
-  }
-})
-
-test('★ 커널은 계약을 다시 내보내지 않는다 — 내보내면 어휘가 엔진 뒤에 숨는다', () => {
-  const contractNames = new Set(Object.keys(contract))
-  const leaked = Object.keys(kernel).filter(n => contractNames.has(n))
-  assert.deepEqual(
-    leaked,
-    [],
-    `커널이 계약 이름을 다시 내보낸다:\n${leaked.slice(0, 20).join(', ')}\n` +
-      '두 경로로 가져올 수 있게 되면 새 코드가 편한 쪽을 쓰고, 사실을 만들기만 하는 쪽이 엔진을 의존하게 된다.'
-  )
-})
-
-test('커널은 엔진을 내보낸다 — 걷어내다가 필요한 것까지 걷지 않았는지 본다', () => {
-  const names = Object.keys(kernel)
-  for (const must of ['EmsKernel', 'MesKernel', 'WmsKernel', 'YmsKernel', 'StateProjector']) {
-    assert.ok(names.includes(must), `${must} 가 커널에 없다`)
-  }
-})

package/test/control-capability.test.ts

@@ -1,98 +0,0 @@
-/*
- * **구동은 선언된 능력이다** — 그리고 원본을 지난다 (ADR-0029 §8, 2026-08-19).
- *
- * ── 무엇이 뚫려 있었나 ──────────────────────────────────────────────────────
- * `controlTwinScenario` 가 트윈의 커널 런타임(`runtime.scenario`)을 **직접** 잡았다. 시뮬만 할 수 있는 일
- * (자극·배속·정지)이 계약 밖의 지름길로 들어온 셈이고, 실 시스템에는 그 자리가 아예 없었다. ADR-0029 의
- * 판정 문장(*"실물이 같은 계약으로 할 수 있는가"*)을 그대로 대면 그 통제면은 영원히 「규약의 결손」이 된다.
- *
- * 뒤집는다: 통제는 **선언된 어댑터 능력**이다. 선언하지 않은 원본에는 문이 열리지 않고, 그 사실이 결손이
- * 아니라 사실이다(실 WMS 는 정지되지 않는다).
- *
- * 이 시험이 지키는 것:
- *  ① 선언과 구현이 **함께** 있어야 능력이다 — 선언만 있으면 화면이 거짓말을 하고, 구현만 있으면 닫아 둔
- *    문을 여는 것이다(선언이 권위다).
- *  ② 능력 없는 원본은 **사유 코드로** 거절한다(들어온 것이 없는 실패 금지).
- *  ③ 없는 기능을 있는 것처럼 답하지 않는다(내장 시뮬은 아직 재씨앗을 못 한다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { capabilitiesOf, type ReferenceAdapter } from '../server/service/reference/reference-adapter.ts'
-
-const base: ReferenceAdapter = {
-  type: 'probe',
-  async testConnection() {
-    return { ok: true }
-  },
-  async discoverSites() {
-    return []
-  },
-  async fetchMaster() {
-    return { source: 'p', system: 'wms', space: { spaceId: 'p-site' }, locations: [] } as any
-  }
-}
-
-test('선언도 구현도 없으면 아무 능력이 없다 — 구조만 주는 원본이 정상이다', () => {
-  assert.deepEqual(capabilitiesOf(base), [])
-})
-
-test('선언만 있으면 능력이 아니다 — 화면이 「할 수 있다」고 말한 뒤 아무 일도 없게 두지 않는다', () => {
-  assert.deepEqual(capabilitiesOf({ ...base, capabilities: ['control'] }), [])
-  assert.deepEqual(capabilitiesOf({ ...base, capabilities: ['live'] }), [])
-})
-
-test('구현만 있으면 능력이 아니다 — 선언이 권위다(닫아 둔 문을 열지 않는다)', () => {
-  assert.deepEqual(capabilitiesOf({ ...base, control: async () => ({ ok: true }) }), [])
-  assert.deepEqual(capabilitiesOf({ ...base, openLiveFeed: () => () => {} }), [])
-})
-
-test('선언과 구현이 함께 있으면 그 능력이다', () => {
-  assert.deepEqual(capabilitiesOf({ ...base, capabilities: ['control'], control: async () => ({ ok: true }) }), ['control'])
-  assert.deepEqual(
-    capabilitiesOf({
-      ...base,
-      capabilities: ['live', 'control'],
-      openLiveFeed: () => () => {},
-      control: async () => ({ ok: true })
-    }),
-    ['live', 'control']
-  )
-})
-
-test('어댑터가 없으면 빈손이다 — 지어내지 않는다', () => {
-  assert.deepEqual(capabilitiesOf(undefined), [])
-})
-
-/*
- * ── 길이 하나뿐인지 (소스로 지킨다) ────────────────────────────────────────
- * 지름길이 남아 있으면 이 결정은 문서상의 것이 된다. 그래서 ① 구동 문이 라우터를 지나고 ② 라우터가 능력을
- * 보고 ③ 트윈 런타임을 직접 잡는 옛 경로가 사라졌는지 본다.
- */
-test('구동 문이 원본을 지난다 — 트윈 런타임을 직접 잡지 않는다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/twin-control/twin-control-mutation.ts', import.meta.url)), 'utf-8')
-  const code = src
-    .split('\n')
-    .filter(line => !/^\s*(\*|\/\/|\/\*)/.test(line))
-    .join('\n')
-  assert.match(code, /routeControl\(domainId, instanceId/, '구동은 라우터를 지난다')
-  assert.equal(/runtime\.scenario\./.test(code), false, '트윈의 시나리오 엔진을 직접 잡는 지름길이 없다')
-  assert.equal(/controlTwinScenario/.test(code), false, '옛 문이 남아 있지 않다')
-  assert.match(code, /twinSourceCapability/, '화면이 먼저 물을 자리가 있다')
-})
-
-test('라우터가 선언을 본다 — 없으면 사유 코드로 거절한다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/reference/control-routing.ts', import.meta.url)), 'utf-8')
-  assert.match(src, /capabilitiesOf\(adapter\)\.includes\('control'\)/)
-  assert.match(src, /'not-declared'/)
-  assert.match(src, /'no-source'/, '원본을 모르는 트윈은 구동 대상이 아니다')
-})
-
-/*
- * The assertion that read `operato-twin/server/board/virtual-adapter.ts` moved to that
- * package's own tests when the applications became their own repository — a guard reading a
- * consumer's source has to live where that source lives, or it scans nothing and says green.
- * See operato-application/packages/operato-twin/test/virtual-adapter-capability.test.ts.
- */

package/test/cursor-stall-not-read-failure.test.ts

@@ -1,126 +0,0 @@
-/*
- * ★ **조치가 반대인 두 사실을 한 이름으로 부르면 그 이름은 정보가 아니라 오해다.**
- *
- * ── 무엇이 반대 방향을 가리켰나 (2026-08-24) ────────────────────────────────
- * 2026-08-23 에 「원본에 닿지 못한다」를 트윈이 말할 수 있게 `onReadFailure` 를 만들었다. 그런데 그 문으로
- * **다른 사실**이 함께 나가고 있었다.
- *
- *   원본에 닿지 못했다        접속 실패·시간 초과 → **기다리면 풀린다**
- *   읽었는데 커서가 못 넘어간다  한 시각에 한 페이지보다 많은 행 → **기다려도 안 풀린다**
- *
- * 둘째는 **읽기가 성공한 실패**다. 원본은 답했고 그 답의 모양이 커서를 이겼다. 그런데 화면이
- * 「원본에 닿지 못한다」고 말하면 사람은 원본을 의심하고 기다린다 — 실제로 필요한 조치는 페이지를
- * 키우거나 같은 시각 안에서 순서를 정하는 것이고, 기다림으로는 영원히 풀리지 않는다.
- *
- * 게다가 그 문구가 스트림 이름을 꺼내는 규칙에 맞지 않아 **어느 표가 막혔는지도 남지 않았다.**
- *
- * ── 이 시험이 지키는 것 ─────────────────────────────────────────────────────
- * ① 두 축이 **서로를 지우지 않는다**  ② 두 축이 **각자 뷰로 나간다**(유입이 없는 갈래에서도)
- * ③ 「몇 번·언제부터」를 정체 쪽도 든다  ④ 넘어가면 지운다
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import {
-  clearCursorStall,
-  clearReadFailure,
-  ingestHealth,
-  newIngestLedger,
-  recordCursorStall,
-  recordIngest,
-  recordReadFailure
-} from '../server/engine/ingest-health.ts'
-
-const T0 = Date.parse('2026-08-24T06:00:00.000Z')
-
-test('정체는 읽기 실패와 **다른 칸**이다 — 서로를 지우지 않는다', () => {
-  /*
-   * ★ 한 칸을 쓰면 나중에 온 것이 앞의 것을 덮는다. 그러면 「닿지 못한다」와 「못 넘어간다」 중
-   * 마지막 것만 남고, 화면은 조치를 반대로 안내할 수 있다.
-   */
-  const l = newIngestLedger()
-  recordReadFailure(l, 'connect ETIMEDOUT', T0, 'inventory')
-  recordCursorStall(l, 'one timestamp holds more rows than a page', T0 + 1000, 'trace')
-  assert.equal(l.readFailure?.reason, 'connect ETIMEDOUT', '읽기 실패가 남아 있다')
-  assert.equal(l.cursorStall?.reason, 'one timestamp holds more rows than a page')
-  assert.equal(l.readFailure?.stream, 'inventory')
-  assert.equal(l.cursorStall?.stream, 'trace', '어느 표가 막혔나가 조치의 절반이다')
-})
-
-test('각자 지워진다 — 하나가 풀렸다고 다른 하나를 지우지 않는다', () => {
-  const l = newIngestLedger()
-  recordReadFailure(l, 'ETIMEDOUT', T0)
-  recordCursorStall(l, 'cursor cannot advance', T0)
-  clearReadFailure(l)
-  assert.equal(l.readFailure, undefined, '다시 닿았다')
-  assert.ok(l.cursorStall, '그렇다고 커서가 넘어간 것은 아니다')
-  clearCursorStall(l)
-  assert.equal(l.cursorStall, undefined, '넘어갔으면 지운다')
-})
-
-test('「몇 번·언제부터」를 정체 쪽도 든다 — 한 번 밀린 것과 사흘째는 다르다', () => {
-  const l = newIngestLedger()
-  recordCursorStall(l, 'stuck at 2026-04-15T01:49', T0)
-  recordCursorStall(l, 'stuck at 2026-04-15T01:49', T0 + 600_000)
-  recordCursorStall(l, 'stuck at 2026-04-15T01:49', T0 + 1_200_000)
-  assert.equal(l.cursorStall?.consecutive, 3)
-  assert.equal(l.cursorStall?.sinceMs, T0, '처음 막힌 시각을 지킨다')
-  assert.equal(l.cursorStall?.lastAtMs, T0 + 1_200_000)
-  /* 넘어간 뒤 다시 막히면 **새 정체**다 — 옛 시작 시각을 물려받지 않는다. */
-  clearCursorStall(l)
-  recordCursorStall(l, 'stuck again', T0 + 3_600_000)
-  assert.equal(l.cursorStall?.consecutive, 1)
-  assert.equal(l.cursorStall?.sinceMs, T0 + 3_600_000)
-})
-
-test('뷰로 나간다 — **유입이 없는 갈래에서도**', () => {
-  /*
-   * ★ 여기가 아무 신호도 나지 않기 가장 쉬운 자리다. 커서가 막히면 유입이 0이므로 장부가 「빈 장부」 갈래를
-   * 지나고, 그 갈래에서 이 값을 떨어뜨리면 **정체가 실제로 일어나는 바로 그 상황에서** 침묵한다.
-   * `unhandled` 를 스냅샷이 떨어뜨려 정합성 검사가 영원히 아무 신호도 내지 않았던 것과 같은 부류다.
-   */
-  const l = newIngestLedger()
-  recordCursorStall(l, 'one timestamp holds more rows than a page', T0, 'trace')
-  const v = ingestHealth(l, 'attached', undefined, T0 + 60_000)
-  assert.ok(v.cursorStall, '유입이 없어도 뷰에 실린다')
-  assert.equal(v.cursorStall?.consecutive, 1)
-  assert.equal(v.cursorStall?.since, new Date(T0).toISOString())
-  assert.equal(v.cursorStall?.stream, 'trace')
-  assert.equal(v.readFailure, undefined, '닿지 못한 것은 아니다 — 섞이지 않는다')
-})
-
-test('유입이 있는 갈래에서도 나간다 — 두 갈래를 다 채운다', () => {
-  /* 갈래가 둘인 함수에서 한쪽만 채우는 실수를 이 저장소가 이미 겪었다. */
-  const l = newIngestLedger()
-  recordIngest(l, 5, [], T0)
-  recordCursorStall(l, 'cursor cannot advance', T0 + 1000, 'lot')
-  const v = ingestHealth(l, 'attached', undefined, T0 + 2000)
-  assert.equal(v.total.offered, 5, '유입이 있는 갈래다 — 빈 비교로 통과하지 않는다')
-  assert.equal(v.cursorStall?.stream, 'lot')
-})
-
-test('막히지 않았으면 그 칸을 만들지 않는다 — 빈 값이 「막혔다」로 읽히지 않게', () => {
-  const l = newIngestLedger()
-  recordIngest(l, 3, [], T0)
-  assert.equal(ingestHealth(l, 'attached', undefined, T0 + 1000).cursorStall, undefined)
-})
-
-test('두 사실이 같은 문으로 나가지 않는다 — 배선을 소스로 확인한다', () => {
-  /*
-   * 장부만 시험하면 **호스트가 여전히 읽기 실패 문으로 보내도** 초록이다. 실제로 그랬던 것이 이 결함의
-   * 시작이었다.
-   */
-  const src = readFileSync(join(import.meta.dirname, '..', 'server', 'service', 'reference', 'reference-live.ts'), 'utf8')
-  const code = src.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/(^|[^:])\/\/.*$/gm, '$1')
-  assert.match(code, /onCursorStall:/, '어댑터의 정체 통로를 잇는다')
-  assert.match(code, /recordIngestCursorStall/, '정체는 정체 장부로 간다')
-  /* 그리고 그 문구가 「닿지 못한다」와 달라야 한다 — 같은 말이면 화면이 여전히 반대로 안내한다. */
-  const at = code.indexOf('onCursorStall:')
-  const body = code.slice(at, at + 900)
-  assert.match(body, /cursor cannot advance/, '무엇이 막혔는지 말한다')
-  assert.match(body, /Waiting will not clear this/, '기다림이 답이 아니라고 말한다')
-  assert.doesNotMatch(body, /recordIngestReadFailure/, '읽기 실패 장부로 보내지 않는다')
-  /* 재부착의 자격(`status`)은 여기서도 건드리지 않는다 — 2026-08-23 에 되돌린 그 규율. */
-  assert.doesNotMatch(body, /status:/, '정체가 피드를 영구히 끄지 않는다')
-})