@things-factory/headless-twin 10.1.277 → 10.1.279

package/test/actuation-rule.test.ts

@@ -1,266 +0,0 @@
-/*
- * **관측에서 조치를 낸다** — 그 판정.
- *
- * ── 무엇이 없었나 (2026-09-01) ───────────────────────────────────────────
- * 승인 게이트를 세우고 나니 낼 수 있는 것이 **사람뿐**이었다. 계약은 낸 쪽을 네 가지로 두는데
- * 사람 말고는 길이 없었다.
- *
- * ── 이 판정에서 무너지는 것 ──────────────────────────────────────────────
- * 행복한 길은 짧다. 실제로 무너지는 것은 이것들이고, 넷 다 오류가 나지 않는다.
- *
- *   같은 조건이 매 주기 다시 올라온다   대기 줄에 같은 지시가 수십 개
- *   방금 생긴 조건에 바로 올린다        깜빡인 것에 현장 지시가 나간다
- *   한 번에 수백 개                     사람이 읽지 않고, 읽지 않으면 게이트는 시늉이다
- *   값이 없는데 지시를 만든다           무엇을 지시하는지 모르는 것이 승인 대기에 선다
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { CMD, MES_COMMANDS, type CommandTypeSpec } from '@operato/ops-contract'
-
-import {
-  DEFAULT_COOLDOWN_MS,
-  DEFAULT_MAX_PER_RUN,
-  evaluateRules,
-  type ActuationRuleSpec,
-  type AttentionLike
-} from '../server/service/actuation/rule-evaluate.js'
-
-const SPECS: readonly CommandTypeSpec[] = MES_COMMANDS
-const ORDER = MES_COMMANDS[0]!
-const NOW = Date.parse('2026-09-01T03:00:00.000Z')
-const HOUR = 3_600_000
-
-/** 세 시간째 이어진 병목 하나. */
-const bottleneck = (over: Partial<AttentionLike> = {}): AttentionLike => ({
-  id: 'bottleneck:paint-1',
-  kind: 'bottleneck',
-  severity: 'high',
-  state: 'active',
-  anchor: { locationId: 'paint-1' },
-  timeStamp: new Date(NOW - 3 * HOUR).toISOString(),
-  params: { ratioPct: 118 },
-  ...over
-})
-
-/** 병목이 오래가면 생산 지시를 낸다 — 품목·단위는 규칙이 정하고 수량도 규칙이 정한다. */
-const rule = (over: Partial<ActuationRuleSpec> = {}): ActuationRuleSpec => ({
-  id: 'rule-1',
-  instanceId: 'twin-a',
-  attentionKind: 'bottleneck',
-  minSeverity: 'high',
-  minHeldMs: 2 * HOUR,
-  commandType: ORDER.type,
-  payloadTemplate: {
-    materialDefinitionId: 'urn:epc:idpat:sgtin:9521234.00001.*',
-    quantity: 20,
-    uom: 'EA',
-    note: '{locationId} 가 {ratioPct}% 로 {attentionKind} 다'
-  },
-  ...over
-})
-
-const run = (args: Partial<Parameters<typeof evaluateRules>[0]> = {}) =>
-  evaluateRules({
-    rules: [rule()],
-    attentions: [bottleneck()],
-    specs: SPECS,
-    openCauses: new Set<string>(),
-    nowMs: NOW,
-    ...args
-  })
-
-/* ── 낸다 ─────────────────────────────────────────────────────────────────── */
-
-test('★ 오래 이어진 조건이 조치로 올라간다 — 이 길이 없어 낼 수 있는 것이 사람뿐이었다', () => {
-  const out = run()
-
-  assert.equal(out.proposals.length, 1)
-  assert.equal(out.proposals[0]!.commandType, ORDER.type)
-  assert.equal(out.proposals[0]!.attentionId, 'bottleneck:paint-1')
-  assert.deepEqual(out.skips, [])
-})
-
-test('★ 주의의 값이 지시에 들어간다 — 승인하는 사람이 왜 올라왔는지 읽을 수 있게', () => {
-  const payload = run().proposals[0]!.payload
-  assert.equal(payload.note, 'paint-1 가 118% 로 bottleneck 다')
-  assert.equal(payload.quantity, 20)
-})
-
-test('★ 값 하나를 그대로 나르는 자리는 수로 남는다 — 수량이 문자열이면 그 뒤 계산이 무너진다', () => {
-  const out = run({
-    rules: [rule({ payloadTemplate: { ...rule().payloadTemplate, quantity: '{ratioPct}' } })]
-  })
-  assert.strictEqual(out.proposals[0]!.payload.quantity, 118, '문자열 "118" 이 되었다')
-})
-
-/* ── 같은 조건을 두 번 올리지 않는다 ─────────────────────────────────────── */
-
-test('★ 이미 올라가 있는 근거에는 다시 올리지 않는다 — 주기마다 같은 지시가 쌓이지 않게', () => {
-  const out = run({ openCauses: new Set(['bottleneck:paint-1']) })
-  assert.equal(out.proposals.length, 0)
-  assert.deepEqual(out.skips, [], '중복은 이유를 말할 것이 아니다 — 정상이다')
-})
-
-test('★ 한 주의에 규칙이 둘 붙어도 조치는 하나다 — 같은 조건에 두 지시가 나가면 현장이 두 번 움직인다', () => {
-  const out = run({ rules: [rule({ id: 'rule-1' }), rule({ id: 'rule-2' })] })
-  assert.equal(out.proposals.length, 1)
-})
-
-test('★ 근거가 저장소에서 온다 — 프로세스 기억에 두면 재기동이 곧 중복이다', () => {
-  /*
-   * 판정이 순수 함수라 「이미 올라간 것」을 인자로 받는다. 재기동한 프로세스도 저장소에서 같은 집합을
-   * 읽어 넘기면 같은 답이 나온다.
-   */
-  const openCauses = new Set(['bottleneck:paint-1'])
-  assert.equal(run({ openCauses }).proposals.length, 0)
-  assert.equal(run({ openCauses: new Set() }).proposals.length, 1, '집합이 비면 다시 올라간다 — 그것이 저장소의 몫이다')
-})
-
-/* ── 깜빡이는 것에 지시를 내지 않는다 ───────────────────────────────────── */
-
-test('★ 아직 짧게 이어진 조건은 올리지 않는다', () => {
-  const out = run({ attentions: [bottleneck({ timeStamp: new Date(NOW - 10_000).toISOString() })] })
-  assert.equal(out.proposals.length, 0)
-})
-
-test('★ 언제부터인지 모르는 주의는 올리지 않고 말한다 — 모름을 「오래됐다」로 읽지 않는다', () => {
-  const out = run({ attentions: [bottleneck({ timeStamp: undefined })] })
-  assert.equal(out.proposals.length, 0)
-  assert.equal(out.skips.length, 1)
-  assert.match(out.skips[0]!.reason, /언제부터인지 말하지 않는다/)
-})
-
-test('모양이 아닌 시각도 모름으로 본다 — 지어낸 기간으로 지시를 내지 않는다', () => {
-  const out = run({ attentions: [bottleneck({ timeStamp: '어제' })] })
-  assert.equal(out.proposals.length, 0)
-  assert.match(out.skips[0]!.reason, /언제부터인지 말하지 않는다/)
-})
-
-test('기간을 요구하지 않는 규칙은 처음 본 주기에 올린다', () => {
-  const out = run({
-    rules: [rule({ minHeldMs: undefined })],
-    attentions: [bottleneck({ timeStamp: new Date(NOW - 1000).toISOString() })]
-  })
-  assert.equal(out.proposals.length, 1)
-})
-
-/* ── 낸 지 얼마 안 된 근거에는 다시 내지 않는다 ─────────────────────────── */
-
-test('★ 승인해도 곧바로 다시 내지 않는다 — 걸어 보고 실제로 만든 상태다', () => {
-  /*
-   * 결정을 기다리는 것만 보고 중복을 막았더니, **승인하는 순간** 그 커맨드가 대기에서 빠지고 조건은
-   * 그대로 서 있어 다음 바퀴가 같은 것을 또 냈다. 사람이 승인할수록 대기 줄이 다시 차는 모양이었다.
-   */
-  const justProposed = new Map([['bottleneck:paint-1', NOW - 60_000]])
-  const out = run({ openCauses: new Set(), lastProposedAt: justProposed })
-  assert.equal(out.proposals.length, 0)
-})
-
-test('★ 기다리는 시간이 지나면 다시 낸다 — 조건이 여전하면 다시 판단거리다', () => {
-  const longAgo = new Map([['bottleneck:paint-1', NOW - 2 * HOUR]])
-  const out = run({ openCauses: new Set(), lastProposedAt: longAgo })
-  assert.equal(out.proposals.length, 1)
-})
-
-test('★ 선언하지 않아도 기다린다 — 그 결함을 기본값으로 두지 않는다', () => {
-  const recent = new Map([['bottleneck:paint-1', NOW - (DEFAULT_COOLDOWN_MS - 1000)]])
-  const out = run({ rules: [rule({ cooldownMs: undefined })], openCauses: new Set(), lastProposedAt: recent })
-  assert.equal(out.proposals.length, 0)
-})
-
-test('0 으로 두면 기다리지 않는다 — 그 뜻을 그대로 존중한다', () => {
-  const justProposed = new Map([['bottleneck:paint-1', NOW - 1000]])
-  const out = run({ rules: [rule({ cooldownMs: 0 })], openCauses: new Set(), lastProposedAt: justProposed })
-  assert.equal(out.proposals.length, 1)
-})
-
-test('낸 적 없는 근거는 기다리지 않는다', () => {
-  const other = new Map([['bottleneck:other', NOW - 1000]])
-  assert.equal(run({ lastProposedAt: other }).proposals.length, 1)
-})
-
-/* ── 무엇을 걸러내나 ─────────────────────────────────────────────────────── */
-
-test('★ 확인한 주의에는 올리지 않는다 — 사람이 이미 본 것이다', () => {
-  assert.equal(run({ attentions: [bottleneck({ state: 'acknowledged' })] }).proposals.length, 0)
-  assert.equal(run({ attentions: [bottleneck({ state: 'cleared' })] }).proposals.length, 0)
-})
-
-test('심각도가 문턱 아래면 올리지 않는다', () => {
-  assert.equal(run({ attentions: [bottleneck({ severity: 'medium' })] }).proposals.length, 0)
-  assert.equal(run({ attentions: [bottleneck({ severity: 'critical' })] }).proposals.length, 1)
-})
-
-test('★ 모르는 심각도는 통과시키지 않는다 — 모름을 「충분하다」로 읽지 않는다', () => {
-  assert.equal(run({ attentions: [bottleneck({ severity: 'ㅁ' })] }).proposals.length, 0)
-})
-
-test('꺼 둔 규칙은 판정하지 않는다 — 지우지 않고 끌 수 있어야 한다', () => {
-  assert.equal(run({ rules: [rule({ enabled: false })] }).proposals.length, 0)
-})
-
-test('다른 종류의 주의는 이 규칙이 보지 않는다', () => {
-  assert.equal(run({ attentions: [bottleneck({ kind: 'scrap-high' })] }).proposals.length, 0)
-})
-
-/* ── 지어낸 값으로 지시를 만들지 않는다 ─────────────────────────────────── */
-
-test('★ 바꿔 넣을 값이 주의에 없으면 올리지 않고 말한다', () => {
-  const out = run({
-    rules: [rule({ payloadTemplate: { ...rule().payloadTemplate, quantity: '{shortfall}' } })]
-  })
-  assert.equal(out.proposals.length, 0)
-  assert.equal(out.skips.length, 1)
-  assert.match(out.skips[0]!.reason, /넣을 값이 주의에 없다/)
-  assert.match(out.skips[0]!.reason, /shortfall/)
-})
-
-test('★ 요구하는 칸이 비면 올리지 않고 말한다 — 무엇을 지시하는지 모르면 승인할 근거가 없다', () => {
-  const out = run({ rules: [rule({ payloadTemplate: { note: '병목' } })] })
-  assert.equal(out.proposals.length, 0)
-  assert.match(out.skips[0]!.reason, /요구하는 칸이 비었다/)
-  for (const key of ORDER.required) assert.match(out.skips[0]!.reason, new RegExp(key))
-})
-
-test('★ 선언되지 않은 조치 종류를 가리키는 규칙은 말한다 — 조용히 아무 일도 안 하지 않는다', () => {
-  const out = run({ rules: [rule({ commandType: 'line.shutdown' })] })
-  assert.equal(out.proposals.length, 0)
-  assert.equal(out.skips.length, 1)
-  assert.match(out.skips[0]!.reason, /선언되지 않은 조치 종류/)
-})
-
-test('★ 커널 자극을 가리키는 규칙도 같은 자리에서 걸린다 — 모델 자극이 현장 지시가 되지 않게', () => {
-  /*
-   * `Attention.suggestedAction.command` 가 나르는 것이 이 어휘다. 주의를 읽어 규칙을 쓰다 보면 그 값이
-   * 손에 잡힌다 — `resource.repair` 는 「모델에서 수리된 것으로 두라」이고 「사람을 보내라」가 아니다.
-   */
-  const out = run({ rules: [rule({ commandType: CMD.resourceRepair })] })
-  assert.equal(out.proposals.length, 0)
-  assert.match(out.skips[0]!.reason, /선언되지 않은 조치 종류/)
-})
-
-/* ── 한 번에 쏟지 않는다 ─────────────────────────────────────────────────── */
-
-test('★ 상한에 닿으면 두고 오고, 두고 온 수를 말한다 — 조용히 자르면 다 올린 줄로 읽는다', () => {
-  const many = Array.from({ length: 30 }, (_, i) =>
-    bottleneck({ id: `bottleneck:line-${i}`, anchor: { locationId: `line-${i}` } })
-  )
-  const out = run({ attentions: many, maxPerRun: 5 })
-
-  assert.equal(out.proposals.length, 5)
-  assert.equal(out.withheld, 25)
-})
-
-test('상한은 기본값이 있다 — 사람이 읽을 수 있는 수', () => {
-  const many = Array.from({ length: DEFAULT_MAX_PER_RUN + 3 }, (_, i) =>
-    bottleneck({ id: `bottleneck:line-${i}`, anchor: { locationId: `line-${i}` } })
-  )
-  const out = run({ attentions: many })
-  assert.equal(out.proposals.length, DEFAULT_MAX_PER_RUN)
-  assert.equal(out.withheld, 3)
-})
-
-test('두고 온 것이 없으면 그 자리를 만들지 않는다 — 0 을 「잘렸다」로 읽히게 하지 않는다', () => {
-  assert.equal(run().withheld, undefined)
-})

package/test/actuation-seam.test.ts

@@ -1,255 +0,0 @@
-/*
- * ★ **커넥터가 적은 선언이 게이트의 답으로 이어지는가** — 오늘 결함이 정확히 이 사이에서 났다.
- *
- * ── 무엇이 났나 (2026-09-02) ────────────────────────────────────────────────
- * 시험은 두 쪽에 다 있었다. 등록 검사를 걷는 것(§`connector-capability-declaration.test.ts`)과
- * 게이트 판정을 걷는 것(§`actuation-target.test.ts`). 그런데 **그 둘을 잇는 것이 없었다.**
- *
- *   MES 커넥터가 actuate 를 다 만들었다
- *   능력 축에 'actuate' 라는 이름이 없었다        ← 여기가 비어 있었다
- *   커넥터는 ['live','control'] 만 적을 수 있었다
- *   넘기는 자리는 「구현이 없습니다」로 답했다
- *
- * 양쪽 시험은 각자 초록이었다. 이어 걷는 시험이 있었으면 그 자리에서 걸렸다.
- *
- * 그래서 이 파일은 **레지스트리에서 값을 꺼내** 게이트에 넣는다. 손으로 적은 값을 넣으면 오늘 났던
- * 어긋남을 그대로 지나친다 — 그 어긋남이 레지스트리와 게이트 사이에 있었기 때문이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-/* 등록 검사가 경고로 말한다 — 그 말도 이 자리에서 함께 본다. */
-const warnings: string[] = []
-const originalWarn = console.warn
-console.warn = (...args: unknown[]) => {
-  warnings.push(args.join(' '))
-}
-process.on('exit', () => (console.warn = originalWarn))
-
-const { registerAdapterType, getAdapter, capabilitiesOf } = await import(
-  '../server/service/reference/reference-adapter.js'
-)
-type ActuationReadiness = import('../server/service/reference/reference-adapter.js').ActuationReadiness
-const { actuationTarget, isActuationAllowed } = await import('../server/service/reference/actuation-target.js')
-
-let seq = 0
-function register(over: Record<string, unknown>) {
-  const type = `seam-${++seq}`
-  registerAdapterType({
-    type,
-    async fetchMaster() {
-      return {} as any
-    },
-    ...over
-  } as any)
-  return type
-}
-
-/**
- * 등록된 커넥터의 **실제 값**으로 게이트에 묻는다 — 배선(§`actuation-routing.ts`)이 하는 것과 같다.
- *
- * 저장소만 여기서 대신한다. 트윈과 원본은 있는 것으로 두고, 갈리는 것은 커넥터가 무엇을 적었나다.
- */
-function askGate(adapterType: string, siteId?: string) {
-  /*
-   * **기본값을 두지 않는다.** 처음에 `siteId = 'plant-a'` 로 두었더니 `askGate(type, undefined)` 가
-   * 기본값을 집어서 「사이트를 모르는 경우」를 시험할 수 없었다 — 시험이 초록인데 아무것도 확인하지
-   * 않는 상태였다. 부르는 쪽이 매번 적는다.
-   */
-  const adapter = getAdapter(adapterType)
-  return actuationTarget({
-    instanceId: 'twin-a',
-    twinExists: true,
-    siteId,
-    ref: { source: 'twin-a', adapterType },
-    adapterRegistered: !!adapter,
-    capabilities: capabilitiesOf(adapter),
-    declaresActuate: !!adapter?.capabilities?.includes('actuate'),
-    hasActuateImpl: typeof adapter?.actuate === 'function'
-  })
-}
-
-/* ── 선언과 구현이 다 있으면 게이트가 열린다 ────────────────────────────────── */
-
-test('★ 커넥터가 조치를 적고 만들었으면 게이트가 열린다 — 이 한 줄이 없어서 하루가 갔다', () => {
-  const before = warnings.length
-  const type = register({ capabilities: ['live', 'actuate'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) })
-
-  assert.equal(warnings.length, before, '맞게 적었는데 등록이 무슨 말을 했다')
-
-  const target = askGate(type, 'plant-a')
-  assert.equal(isActuationAllowed(target), true, '커넥터는 조치를 낼 수 있는데 게이트가 막았다')
-  assert.deepEqual(target, { ok: true, siteId: 'plant-a', adapterType: type, source: 'twin-a' })
-})
-
-/* ── 오늘 났던 상태를 그대로 세운다 ─────────────────────────────────────────── */
-
-test('★ 구현만 있고 선언이 없으면 — 등록이 말하고, 게이트도 같은 것을 말한다', () => {
-  /*
-   * 이것이 오늘의 상태다. 두 자리가 **같은 원인을 같은 말로** 짚어야 한다. 등록 경고는 뜰 때 한 번
-   * 지나가고 아무도 안 볼 수 있다. 넘기려는 사람이 보는 것은 게이트의 답이다.
-   */
-  const before = warnings.length
-  const type = register({ capabilities: ['live'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) })
-
-  const said = warnings.slice(before).join('\n')
-  assert.ok(said.includes('actuate'), '등록이 조치 선언이 빠진 것을 말하지 않았다')
-
-  const target = askGate(type, 'plant-a') as any
-  assert.equal(target.code, 'not-declared')
-  assert.match(target.detail, /capabilities/, '게이트가 무엇을 넣어야 하는지 말하지 않았다')
-})
-
-test('★ 선언만 있고 구현이 없으면 — 등록도 게이트도 말한다', () => {
-  /*
-   * 이 시험은 2026-09-16 까지 「등록은 조용하고, 게이트만 말한다」였다. 그때 주석이 그 침묵을 이렇게
-   * 적어 두었다 — 「등록 검사는 이 방향을 보지 않는다. 그래서 **게이트가 말하지 않으면 아무도 말하지
-   * 않는다**」. 그 문장이 곧 결함의 서술이었다: 조치를 넘기는 자리까지 가 본 사람만 그 사실을 듣고,
-   * 커넥터를 만든 사람은 선언했으니 된 줄 안다.
-   *
-   * ADR-0036 ③ 개정으로 등록이 양방향을 본다. 게이트의 문장은 그대로다 — 그 사람은 조치를 하겠다고
-   * 적어 두었으니 「관측만 냅니다」는 여전히 사실이 아니다.
-   */
-  const before = warnings.length
-  const type = register({ capabilities: ['live', 'actuate'], openLiveFeed: () => () => {} })
-
-  const said = warnings.slice(before).join('\n')
-  assert.ok(said.includes('actuate'), '등록이 증명 없는 선언을 말하지 않았다')
-  assert.ok(said.includes('declares'), '등록이 어느 방향의 어긋남인지 말하지 않았다')
-  assert.deepEqual(capabilitiesOf(getAdapter(type)), ['live'], '능력 판정이 구현 없는 선언을 걸러 내지 않았다')
-
-  const target = askGate(type, 'plant-a') as any
-  assert.equal(target.code, 'not-implemented')
-  assert.doesNotMatch(target.detail, /관측만/)
-})
-
-test('선언도 구현도 없으면 이 커넥터는 조치를 받지 않는다', () => {
-  const type = register({ capabilities: ['live'], openLiveFeed: () => () => {} })
-
-  const target = askGate(type, 'plant-a') as any
-  assert.equal(target.code, 'not-supported')
-  assert.match(target.detail, /관측만/)
-})
-
-/* ── 게이트가 여는 것은 능력 판정을 지난 것뿐이다 ──────────────────────────── */
-
-test('★ 등록된 커넥터마다 게이트의 답이 능력 판정과 어긋나지 않는다', () => {
-  /*
-   * 이것이 이 파일의 요점이다. 「능력에 actuate 가 있다」와 「게이트가 열린다」가 **항상 같이** 가야
-   * 한다. 오늘은 둘이 갈렸다 — 능력 축에 그 이름이 없어서 앞엣것이 영원히 거짓이었고, 게이트는
-   * 그것과 무관하게 무조건 닫혀 있었다.
-   */
-  const cases = [
-    { capabilities: ['live', 'actuate'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) },
-    { capabilities: ['live'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) },
-    { capabilities: ['live', 'actuate'], openLiveFeed: () => () => {} },
-    { capabilities: ['actuate'], actuate: async () => ({ ok: true }) },
-    { capabilities: ['live'], openLiveFeed: () => () => {} },
-    {}
-  ]
-
-  for (const spec of cases) {
-    const type = register(spec)
-    const canActuate = capabilitiesOf(getAdapter(type)).includes('actuate')
-    const opened = isActuationAllowed(askGate(type, 'plant-a'))
-
-    assert.equal(
-      opened,
-      canActuate,
-      `능력 판정은 ${canActuate} 인데 게이트는 ${opened} 로 답했다 (${JSON.stringify(Object.keys(spec))})`
-    )
-  }
-})
-
-/* ── 사이트를 모르면 능력과 무관하게 닫힌다 ────────────────────────────────── */
-
-test('★ 조치를 낼 수 있는 커넥터라도 사이트를 모르면 닫힌다 — 잘못된 공장이 만든다', () => {
-  const type = register({ capabilities: ['actuate'], actuate: async () => ({ ok: true }) })
-
-  assert.equal(isActuationAllowed(askGate(type, 'plant-a')), true)
-  assert.equal((askGate(type, undefined) as any).code, 'no-site')
-  assert.equal((askGate(type, '   ') as any).code, 'no-site')
-})
-
-test('등록되지 않은 커넥터를 가리키면 능력을 묻기 전에 닫힌다', () => {
-  const target = askGate('seam-없는-커넥터', 'plant-a') as any
-
-  assert.equal(target.code, 'no-adapter')
-  assert.match(target.detail, /seam-없는-커넥터/, '어느 커넥터인지 말하지 않으면 찾을 수 없다')
-})
-
-/* ── 저쪽이 받을 준비가 됐나 ────────────────────────────────────────────────── */
-
-test('★ 확인할 길이 없으면 「준비됐다」로 답하지 않는다 — 없는 확인을 통과로 읽지 않게', async () => {
-  /*
-   * 실측(2026-09-03): 승인된 조치를 넘겼더니 저쪽이 503 을 답했다 — 저쪽 프로세스에 비밀값이 실려
-   * 있지 않았다. 우리 쪽 설정·주소·서명은 다 맞았다. 보내 보기 전에는 알 수 없어서 사람이 승인
-   * 화면까지 가서 누르고, 실패를 보고, 다시 로그인했다.
-   *
-   * 그래서 커넥터에 「받을 준비가 됐나」를 묻는 얼굴을 뒀다. 안 만든 커넥터에 대해 이 자리가
-   * 「준비됐다」로 답하면, 얼굴이 있으나 없으나 같아진다.
-   */
-  const type = register({ capabilities: ['actuate'], actuate: async () => ({ ok: true }) })
-  const adapter = getAdapter(type)
-
-  assert.equal(typeof adapter?.actuationReadiness, 'undefined', '이 커넥터는 그 얼굴을 만들지 않았다')
-
-  /* 판정만 걷는다 — 배선은 저장소를 지나므로 여기서 세우지 않는다(§ 이 파일의 머리말). */
-  const answer = notCheckable(type)
-  assert.equal(answer.ready, undefined, '모름을 참·거짓으로 답했다')
-  assert.equal(answer.code, 'not-checkable')
-})
-
-test('★ 「모른다」와 「안 된다」가 다른 값이다', () => {
-  const unknown = notCheckable('some-connector')
-  const refused: ActuationReadiness = { checked: 'local', ready: false, reason: '주소가 없습니다', code: 'no-endpoint' }
-
-  assert.equal(unknown.ready, undefined)
-  assert.equal(refused.ready, false)
-  assert.notEqual(unknown.code, refused.code)
-})
-
-test('어디까지 봤는지 함께 답한다 — 「살아 있다고 말한 적 없다」와 「죽었다」는 다르다', () => {
-  assert.equal(notCheckable('x').checked, 'local')
-})
-
-/**
- * 배선이 커넥터에 얼굴이 없을 때 만드는 답 — 그 모양을 여기서 못 박는다.
- *
- * 저장소를 지나는 함수(§`actuationReadinessOf`)를 부르면 시험이 TypeORM 을 세워야 한다. 그 답의
- * **모양**이 계약이고, 모양이 바뀌면 화면이 조용히 다르게 읽는다.
- */
-function notCheckable(adapterType: string): ActuationReadiness {
-  return {
-    checked: 'local',
-    reason: `커넥터 "${adapterType}" 는 저쪽이 받을 준비가 됐는지 알려 주지 않습니다 — 넘겨 보고 알게 됩니다`,
-    code: 'not-checkable'
-  }
-}
-
-/* ── 화면이 부를 자리가 있는가 ─────────────────────────────────────────────── */
-
-test('★ 판정 함수를 부르는 자리가 있다 — 없으면 화면이 물을 방법이 없다', () => {
-  /*
-   * 판정을 만들어 두고 **부르는 자리를 안 만들었다.** 인티그레이션 레인이 두 번 짚어 줬다 —
-   * `actuationTargetOf` 도, 오늘 만든 `actuationReadinessOf` 도 부르는 곳이 없었다.
-   *
-   * 그래서 못 넘기는 조치도 눌러 보고 알게 됐고, 저쪽에 비밀값이 없던 날 승인 하나가 헛돌았다.
-   * 이 시험은 그 자리가 스키마에 서 있는지 본다 — 문자열로 세는 것이 약하지만, 없어지는 것을
-   * 잡는 데는 충분하다(리졸버를 세우려면 type-graphql 스키마를 지어야 한다).
-   */
-  const source = readFileSync(
-    new URL('../server/service/actuation/twin-command-resolver.ts', import.meta.url).pathname,
-    'utf-8'
-  )
-
-  assert.match(source, /twinActuationReadiness/, '화면이 부를 조회가 없다')
-  assert.match(source, /actuationTargetOf/, '대상 판정을 부르지 않는다')
-  assert.match(source, /actuationReadinessOf/, '준비 판정을 부르지 않는다')
-
-  /* 조회여야 한다 — 이 답으로 넘김을 막지 않으므로 뮤테이션이 아니다. */
-  const at = source.indexOf('twinActuationReadiness')
-  const before = source.slice(Math.max(0, at - 400), at)
-  assert.match(before, /@Query/, '알림인데 뮤테이션으로 두었다')
-})