@things-factory/headless-twin 10.0.18 → 10.1.0

package/test/actuation-effect.test.ts

@@ -0,0 +1,162 @@
+/*
+ * **나간 지시와 돌아온 관측을 잇는다** — 그 판정.
+ *
+ * `dispatchRef` 는 쓰는 곳만 있고 읽는 곳이 없었다. 그래서 조치를 넘긴 뒤 저쪽에서 그것이 어떻게
+ * 됐는지 트윈이 몰랐고, 화면은 「넘겼다」까지만 보여 주고 끝난 것처럼 읽혔다.
+ *
+ * 여기서 지키는 것은 셋이다.
+ *
+ *   이어지나          우리가 낸 지시의 식별자로 돌아온 보고를 찾는가
+ *   해석하지 않나      커널이 「released 는 나간 것」 같은 방언을 알지 않는가
+ *   버리지 않나        못 이은 보고의 이유가 남는가
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  matchEffects,
+  refsToLookUp,
+  type DispatchedCommand,
+  type OrderObservation
+} from '../server/service/actuation/effect-match.js'
+
+const AT = '2026-09-02T09:00:00.000Z'
+const LATER = '2026-09-02T09:05:00.000Z'
+
+const ob = (over: Partial<OrderObservation> = {}): OrderObservation => ({
+  orderId: 'WO-20260902-002',
+  status: 'released',
+  at: AT,
+  ...over
+})
+
+function byRef(...commands: DispatchedCommand[]) {
+  return new Map(commands.map(c => [c.dispatchRef, c]))
+}
+
+const cmd = (over: Partial<DispatchedCommand> = {}): DispatchedCommand => ({
+  id: 'cmd-1',
+  dispatchRef: 'WO-20260902-002',
+  ...over
+})
+
+/* ── 이어진다 ───────────────────────────────────────────────────────────────── */
+
+test('★ 우리가 낸 지시의 식별자로 돌아온 보고를 잇는다 — 이것이 폐루프의 마지막 칸이다', () => {
+  const out = matchEffects({ observations: [ob()], byRef: byRef(cmd()) })
+
+  assert.deepEqual(out.updates, [{ commandId: 'cmd-1', status: 'released', at: AT, seen: 1 }])
+  assert.deepEqual(out.skips, [])
+})
+
+test('★ 상태를 해석하지 않는다 — 커널은 어느 값이 「현장에 나갔다」인지 모른다', () => {
+  /*
+   * 오더 상태 어휘는 도메인 소유다(`OrderStatusDelta.status` 는 열린 문자열이고 코어가 강제하지
+   * 않는다). 커널이 `released` 를 특별히 알면 그 방언을 쓰지 않는 현장에서 폐루프가 조용히 안 닫힌다.
+   *
+   * 그래서 무엇이 와도 그대로 적는다 — 뜻은 그 어휘를 아는 쪽이 읽는다.
+   */
+  for (const status of ['released', 'in-progress', '작업중', 'WIP', 'cancelled']) {
+    const out = matchEffects({ observations: [ob({ status })], byRef: byRef(cmd()) })
+    assert.equal(out.updates[0]?.status, status, `${status} 를 그대로 적지 않았다`)
+  }
+})
+
+test('취소 보고도 효과다 — 저쪽에서 무엇이 되었나이지 잘 되었나가 아니다', () => {
+  const out = matchEffects({ observations: [ob({ status: 'cancelled' })], byRef: byRef(cmd()) })
+
+  assert.equal(out.updates.length, 1, '나쁜 소식을 걸러 내면 화면이 여전히 「넘겼다」로 끝난다')
+  assert.equal(out.updates[0]!.status, 'cancelled')
+})
+
+/* ── 몇 번 바뀌었나를 남긴다 ────────────────────────────────────────────────── */
+
+test('★ 상태가 여러 번 바뀌면 마지막이 남고 센 수가 는다', () => {
+  const out = matchEffects({
+    observations: [ob({ status: 'released', at: AT }), ob({ status: 'in-progress', at: LATER })],
+    byRef: byRef(cmd())
+  })
+
+  assert.equal(out.updates.length, 1, '같은 조치에 두 줄을 냈다')
+  assert.deepEqual(out.updates[0], { commandId: 'cmd-1', status: 'in-progress', at: LATER, seen: 2 })
+})
+
+test('★ 이미 적힌 효과에서 이어 센다 — 다음 묶음이 1로 되돌리지 않는다', () => {
+  const out = matchEffects({
+    observations: [ob({ status: 'in-progress', at: LATER })],
+    byRef: byRef(cmd({ effect: { status: 'released', at: AT, seen: 3 } }))
+  })
+
+  assert.equal(out.updates[0]!.seen, 4)
+})
+
+/* ── 못 이은 것은 이유가 남는다 ─────────────────────────────────────────────── */
+
+test('★ 우리가 내지 않은 오더는 이유로 남는다 — 대개 이것이고, 결함이 아니다', () => {
+  /*
+   * 저쪽 시스템은 자기 오더를 다 보고하고 그중 우리가 낸 것은 일부다. 이 줄이 쌓이는 것을 결함으로
+   * 읽으면 안 된다 — 그래서 이유 문장이 그렇게 말한다.
+   */
+  const out = matchEffects({ observations: [ob({ orderId: 'WO-남의것' })], byRef: byRef(cmd()) })
+
+  assert.deepEqual(out.updates, [])
+  assert.equal(out.skips.length, 1)
+  assert.match(out.skips[0]!.reason, /우리가 낸 지시가 아니다/)
+  assert.equal(out.skips[0]!.orderId, 'WO-남의것', '어느 오더였는지 말하지 않으면 되짚을 수 없다')
+})
+
+test('★ 시각이 없는 보고는 「지금」으로 채우지 않는다 — 처리 시각이 관측 시각이 된다', () => {
+  const out = matchEffects({ observations: [ob({ at: undefined })], byRef: byRef(cmd()) })
+
+  assert.deepEqual(out.updates, [])
+  assert.match(out.skips[0]!.reason, /지금으로 채우지 않는다/)
+})
+
+test('★ 상태가 빈 보고는 효과로 적지 않는다 — 「아무 말도 안 했다」가 「효과 없음」이 된다', () => {
+  for (const status of ['', '   ']) {
+    const out = matchEffects({ observations: [ob({ status })], byRef: byRef(cmd()) })
+    assert.deepEqual(out.updates, [], `${JSON.stringify(status)} 를 효과로 적었다`)
+    assert.match(out.skips[0]!.reason, /빈 값을 효과로 적지 않는다/)
+  }
+})
+
+test('오더 식별자가 없는 보고도 이유로 남는다', () => {
+  const out = matchEffects({ observations: [ob({ orderId: '  ' })], byRef: byRef(cmd()) })
+
+  assert.deepEqual(out.updates, [])
+  assert.match(out.skips[0]!.reason, /식별자가 없는/)
+})
+
+test('보고가 없으면 아무것도 만들지 않는다 — 빈 묶음에 이유를 만들지 않는다', () => {
+  const out = matchEffects({ observations: [], byRef: byRef(cmd()) })
+
+  assert.deepEqual(out.updates, [])
+  assert.deepEqual(out.skips, [])
+})
+
+/* ── 여러 조치 ──────────────────────────────────────────────────────────────── */
+
+test('★ 한 묶음이 여러 조치에 닿으면 각각 적는다 — 하나만 잇고 끝내지 않는다', () => {
+  const out = matchEffects({
+    observations: [ob({ orderId: 'WO-1' }), ob({ orderId: 'WO-2', status: 'in-progress' }), ob({ orderId: 'WO-남의것' })],
+    byRef: byRef(cmd({ id: 'cmd-1', dispatchRef: 'WO-1' }), cmd({ id: 'cmd-2', dispatchRef: 'WO-2' }))
+  })
+
+  assert.equal(out.updates.length, 2)
+  assert.deepEqual(
+    out.updates.map(u => [u.commandId, u.status]).sort(),
+    [
+      ['cmd-1', 'released'],
+      ['cmd-2', 'in-progress']
+    ]
+  )
+  assert.equal(out.skips.length, 1)
+})
+
+/* ── 저장소에 물을 것을 줄인다 ─────────────────────────────────────────────── */
+
+test('★ 찾아볼 식별자만 골라 낸다 — 유입은 초당 수천 건이 지나는 자리다', () => {
+  const observations = [ob({ orderId: 'WO-1' }), ob({ orderId: 'WO-1' }), ob({ orderId: 'WO-2' }), ob({ orderId: '  ' })]
+
+  assert.deepEqual(refsToLookUp(observations).sort(), ['WO-1', 'WO-2'], '중복이나 빈 값을 저장소에 물었다')
+})

package/test/actuation-outcome.test.ts

@@ -0,0 +1,152 @@
+/*
+ * ★ **조치가 어떻게 됐나** — 승인한 사람에게 돌려줄 사실, 그리고 그 안의 판정 하나.
+ *
+ * ── 이 판정이 왜 커널에 있나 (2026-09-04) ──────────────────────────────────
+ * 「저쪽에서 사람이 할 일이 남았나」의 답이 한 필드에 없다. `dispatchNote` 만 보면 틀린다 —
+ * 그것은 **넘길 때 저쪽이 한 말**이고, 사람이 나중에 지시서를 골라도 그대로 남는다. 저쪽에 다시
+ * 물을 일이 없어 갱신되지 않는다(인티그레이션 레인이 MES 코드를 읽어 찾았다).
+ *
+ * 그래서 답은 「말이 있고 효과가 아직 없을 때」다. 그 겹침을 화면마다 하게 두면 목록·상세·알림이
+ * 각자 겹치고 한 곳이 빠진 날 그 화면만 다른 말을 한다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { actuationOutcomeOf } from '../server/service/actuation/actuation-outcome.js'
+import type { StoredCommand } from '../server/service/actuation/command-dispatcher.js'
+
+const at = (over: Partial<StoredCommand> = {}): StoredCommand =>
+  ({
+    id: 'cmd-1',
+    instanceId: 'mes-line-a',
+    kind: 'production.release',
+    proposedBy: 'rule',
+    origin: 'rule',
+    state: 'acked',
+    ...over
+  }) as StoredCommand
+
+/* ── 저쪽에 할 일이 남았나 ───────────────────────────────────────────────── */
+
+test('★ 말이 있고 효과가 아직 없으면 저쪽에 할 일이 남았다', () => {
+  const out = actuationOutcomeOf(at({ dispatchNote: '지시서를 골라야 합니다' }), false)
+
+  assert.equal(out.pendingAtSource, true)
+  assert.equal(out.note, '지시서를 골라야 합니다')
+})
+
+test('★ 효과가 오면 할 일이 끝났다 — 말은 그대로 남아 있어도', () => {
+  /*
+   * 이것이 이 판정의 존재 이유다. `dispatchNote` 는 갱신되지 않으므로 그것만 보면 사람이 지시서를
+   * 고른 뒤에도 「골라야 합니다」가 계속 보인다. 이미 처리된 일을 계속 시키는 화면이 된다.
+   */
+  const out = actuationOutcomeOf(
+    at({ dispatchNote: '지시서를 골라야 합니다', effect: { status: 'released', at: '2026-09-04T01:00:00.000Z', seen: 1 } }),
+    false
+  )
+
+  assert.equal(out.pendingAtSource, false, '효과가 왔는데 아직 할 일이 남았다고 답했다')
+  assert.equal(out.note, '지시서를 골라야 합니다', '기록은 지우지 않는다 — 왜 늦었는지가 사라진다')
+  assert.equal(out.effectStatus, 'released')
+})
+
+test('★ 다음에 할 일이 갈라져 오면 그대로 낸다 — 화면이 문장을 자르지 않게', () => {
+  const out = actuationOutcomeOf(
+    at({ dispatchNote: '접수됐지만 지시서가 붙지 않았습니다', dispatchNoteNext: 'MES 에서 지시서를 골라야 현장에 나갑니다' }),
+    false
+  )
+
+  assert.equal(out.note, '접수됐지만 지시서가 붙지 않았습니다')
+  assert.equal(out.noteNext, 'MES 에서 지시서를 골라야 현장에 나갑니다')
+  assert.equal(out.pendingAtSource, true)
+})
+
+test('★ 어댑터가 아직 안 갈랐으면 비운다 — 없는 줄을 만들지 않는다', () => {
+  /*
+   * 그때 `note` 는 두 문장이 붙은 한 덩이이고, 화면은 통째로 그려야 한다. 커널이 그것을 잘라
+   * 두 칸에 넣으면 **파싱 규칙이 커널에 생기고** 번역되면 깨진다.
+   */
+  const out = actuationOutcomeOf(at({ dispatchNote: '원인과 다음 할 일이 붙은 한 문장입니다' }), false)
+
+  assert.equal(out.note, '원인과 다음 할 일이 붙은 한 문장입니다')
+  assert.equal('noteNext' in out, false)
+})
+
+test('★ 말이 없으면 할 일이 없다', () => {
+  assert.equal(actuationOutcomeOf(at(), false).pendingAtSource, false)
+})
+
+test('★ 아직 넘겨 보지 않았으면 판정하지 않는다 — 「없다」와 「모른다」는 다르다', () => {
+  /*
+   * `approved` 는 승인만 된 상태다. 저쪽에 물어본 적이 없으니 할 일이 남았는지 알 방법이 없다.
+   * `false` 로 접으면 화면이 「할 일 없음」으로 그리고, 그것은 넘긴 뒤와 구별되지 않는다.
+   */
+  for (const state of ['proposed', 'approved', 'rejected']) {
+    const out = actuationOutcomeOf(at({ state, dispatchNote: '지시서를 골라야 합니다' }), true)
+    assert.equal(out.pendingAtSource, undefined, `${state} 인데 판정했다`)
+  }
+})
+
+test('넘긴 상태 셋에서는 판정한다', () => {
+  for (const state of ['dispatching', 'acked', 'failed']) {
+    const out = actuationOutcomeOf(at({ state }), false)
+    assert.equal(out.pendingAtSource, false, `${state} 인데 판정을 비웠다`)
+  }
+})
+
+/* ── 저쪽 낱말을 해석하지 않는다 ────────────────────────────────────────── */
+
+test('★ 효과 상태를 그대로 낸다 — 어느 값이 「현장에 나갔다」인지는 도메인이 안다', () => {
+  for (const status of ['released', 'closed', 'WAITING', '작업중']) {
+    const out = actuationOutcomeOf(at({ effect: { status, at: '2026-09-04T01:00:00.000Z', seen: 2 } }), false)
+    assert.equal(out.effectStatus, status)
+    assert.equal(out.pendingAtSource, false, `${status} 를 「효과 없음」으로 읽었다`)
+  }
+})
+
+/* ── 되돌릴 수 있나 ─────────────────────────────────────────────────────── */
+
+test('★ 되돌릴 수 있으면 그렇게 낸다 — 화면은 참일 때만 한 줄 낸다', () => {
+  assert.equal(actuationOutcomeOf(at({ reversible: true }), false).reversible, true)
+})
+
+test('★ 모르면 비운다 — 「되돌릴 수 없습니다」를 커널이 단언하지 않는다', () => {
+  /*
+   * 늘 참인 경고는 사흘이면 안 읽힌다(UX 레인 판단). 그러니 흔한 쪽을 단언하지 않고, 드문 쪽만
+   * 값으로 낸다. 커널이 `false` 를 채워 보내면 화면이 그것을 그릴 유혹이 생긴다.
+   */
+  assert.equal(actuationOutcomeOf(at(), false).reversible, undefined)
+})
+
+test('돌이킬 수 없다고 선언된 것은 그대로 낸다', () => {
+  assert.equal(actuationOutcomeOf(at({ reversible: false }), false).reversible, false)
+})
+
+/* ── 나머지 사실 ────────────────────────────────────────────────────────── */
+
+test('★ 나간 것은 저쪽 이름을 든다 — 없으면 무엇을 되돌릴지 지목할 수 없다', () => {
+  const out = actuationOutcomeOf(at({ dispatchRef: 'WO-20260903-001' }), false)
+  assert.equal(out.dispatchRef, 'WO-20260903-001')
+})
+
+test('★ 못 나간 것은 사유를 든다', () => {
+  const out = actuationOutcomeOf(at({ state: 'failed', error: 'MES 가 받지 않았습니다 — unknown material ITEM-1' }), true)
+
+  assert.equal(out.state, 'failed')
+  assert.match(out.error!, /unknown material/)
+  assert.equal(out.dispatchable, true, '다시 넘길 수 있는 상태다')
+})
+
+test('★ 종착이면 다시 넘기지 않는다', () => {
+  assert.equal(actuationOutcomeOf(at({ state: 'acked' }), false).dispatchable, false)
+})
+
+test('없는 값으로 키를 만들지 않는다 — 화면이 빈 줄을 그리지 않게', () => {
+  const out = actuationOutcomeOf(at(), false)
+
+  for (const k of ['dispatchRef', 'error', 'note', 'effectStatus', 'effectAt', 'reversible']) {
+    assert.equal(k in out, false, `${k} 가 빈 값으로 들어 있다`)
+  }
+  assert.equal(out.id, 'cmd-1')
+  assert.equal(out.state, 'acked')
+})

package/test/actuation-rule-runner.test.ts

@@ -0,0 +1,281 @@
+/*
+ * **규칙 주기가 저장소에 닿는다** — 그 배선.
+ *
+ * 판정 자체는 `actuation-rule.test.ts` 가 지킨다. 여기서 보는 것은 **그 판정이 실제 경로에 서 있는가**다
+ * — 커맨드가 적혔는가, 근거가 남았는가, 다시 세운 뒤에도 중복이 안 나는가, 한 트윈이 실패해도 나머지가
+ * 도는가.
+ *
+ * 이 저장소에서 가장 자주 나는 결함이 「자리는 있고 길이 없다」이고, 규칙이 그 부류로 나면 두 결과 중
+ * 하나다 — 아무 지시도 안 나가거나, 같은 지시가 대기 줄에 쌓인다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { MES_COMMANDS } from '@operato/ops-contract'
+
+import type { CommandStore, StoredCommand } from '../server/service/actuation/command-dispatcher.js'
+import type { ActuationRuleSpec, AttentionLike } from '../server/service/actuation/rule-evaluate.js'
+import { runRulesOnce, type RuleRunnerDeps } from '../server/service/actuation/rule-runner.js'
+
+const NOW = Date.parse('2026-09-01T03:00:00.000Z')
+const HOUR = 3_600_000
+const TWIN = { domainId: 'd-1', instanceId: 'twin-a' }
+const ORDER = MES_COMMANDS[0]!
+
+const attention = (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.instanceId,
+  attentionKind: 'bottleneck',
+  minHeldMs: 2 * HOUR,
+  commandType: ORDER.type,
+  payloadTemplate: { materialDefinitionId: 'urn:epc:idpat:sgtin:9521234.00001.*', quantity: 20, uom: 'EA' },
+  ...over
+})
+
+/** 저장본 하나 — 프로세스가 아니라 여기 산다. 그래서 다시 세워도 남는다. */
+function makeStore(seed: StoredCommand[] = []) {
+  const rows = new Map<string, StoredCommand>(seed.map(c => [c.id, c]))
+  const store: CommandStore & { rows: Map<string, StoredCommand> } = {
+    rows,
+    load: async (_d, id) => rows.get(id) ?? null,
+    save: async (_d, c) => void rows.set(c.id, JSON.parse(JSON.stringify(c))),
+    create: async (_d, c) => {
+      const copy: StoredCommand = JSON.parse(JSON.stringify(c))
+      rows.set(copy.id, copy)
+      return copy
+    },
+    openCauses: async (_d, instanceId) =>
+      new Set(
+        [...rows.values()]
+          .filter(c => c.instanceId === instanceId && c.state === 'proposed' && c.causeRef)
+          .map(c => c.causeRef!)
+      )
+  }
+  return store
+}
+
+function deps(over: Partial<RuleRunnerDeps> = {}): RuleRunnerDeps {
+  return {
+    ownedTwins: () => [TWIN],
+    rulesOf: async () => [rule()],
+    attentionsOf: () => [attention()],
+    modeOf: () => 'live' as const,
+    store: makeStore(),
+    specs: MES_COMMANDS,
+    nowMs: () => NOW,
+    ...over
+  }
+}
+
+/* ── 실제로 적힌다 ────────────────────────────────────────────────────────── */
+
+test('★ 규칙이 낸 조치가 저장소에 적힌다 — 판정만 있고 적히지 않으면 아무 일도 없다', async () => {
+  const store = makeStore()
+  const out = await runRulesOnce(deps({ store }))
+
+  assert.equal(out.length, 1)
+  assert.equal(out[0]!.proposed, 1)
+  assert.equal(store.rows.size, 1)
+
+  const row = [...store.rows.values()][0]!
+  assert.equal(row.state, 'proposed')
+  assert.equal(row.type, ORDER.type)
+  assert.equal(row.payload.quantity, 20)
+})
+
+test('★ 근거가 커맨드에 남는다 — 이것이 없으면 다음 주기가 같은 것을 또 올린다', async () => {
+  const store = makeStore()
+  await runRulesOnce(deps({ store }))
+  const row = [...store.rows.values()][0]!
+
+  assert.equal(row.causeRef, 'bottleneck:paint-1')
+  assert.equal(row.ruleRef, 'rule-1')
+})
+
+test('★ 규칙이 낸 것에는 낸 사람이 없다 — 사람이 아니므로 아무 승인자든 두 번째 사람이 된다', async () => {
+  const store = makeStore()
+  await runRulesOnce(deps({ store }))
+  const row = [...store.rows.values()][0]!
+
+  assert.equal(row.origin, 'rule')
+  assert.equal(row.proposedBy, undefined)
+})
+
+test('★ 규칙은 결재선에 올리지 않는다 — 배경 루프에는 「나」가 없어 Myself·MySupervisor 가 뜻을 잃는다', async () => {
+  const store = makeStore()
+  await runRulesOnce(deps({ store }))
+  const row = [...store.rows.values()][0]!
+
+  assert.equal(row.approvalRef, undefined, '올렸다면 결재선이 시스템 사용자 기준으로 풀린다')
+  assert.equal(row.state, 'proposed', '올리는 것은 사람이 한다 — 그때까지 게이트는 서 있다')
+})
+
+/* ── 시늉된 조건에서 현장 지시를 내지 않는다 ─────────────────────────────── */
+
+test('★ 시뮬 트윈에는 조치를 내지 않는다 — 지어낸 조건이 현장 지시가 되지 않게', async () => {
+  /*
+   * 시뮬 트윈의 병목은 커널이 스스로 물품을 옮겨 만든 것이다. 현장에서 관측된 것이 아니다.
+   * 오늘 규칙을 확인한 트윈이 전부 `sim` 이었고 시늉된 병목에서 생산 지시가 올라왔다 — 배선은
+   * 옳게 돌았지만 근거가 가정이었다.
+   */
+  const store = makeStore()
+  const out = await runRulesOnce(deps({ store, modeOf: () => 'sim' }))
+
+  assert.equal(out[0]!.proposed, 0)
+  assert.equal(store.rows.size, 0)
+  assert.match(out[0]!.skips[0]!.reason, /시뮬레이션이다/)
+})
+
+test('★ 모드를 모르면 내지 않는다 — 모름을 「관측이다」로 읽지 않는다', async () => {
+  const store = makeStore()
+  const out = await runRulesOnce(deps({ store, modeOf: () => undefined }))
+
+  assert.equal(out[0]!.proposed, 0)
+  assert.match(out[0]!.skips[0]!.reason, /알 수 없다/)
+})
+
+/* ── 두 번 올리지 않는다 ─────────────────────────────────────────────────── */
+
+test('★ 두 번 돌아도 하나만 적힌다', async () => {
+  const store = makeStore()
+  const d = deps({ store })
+
+  await runRulesOnce(d)
+  const second = await runRulesOnce(d)
+
+  assert.equal(second[0]!.proposed, 0)
+  assert.equal(store.rows.size, 1, '같은 조건에 지시가 둘 적혔다')
+})
+
+test('★ 재기동해도 두 번 올리지 않는다 — 근거를 저장소에서 읽기 때문이다', async () => {
+  const first = makeStore()
+  await runRulesOnce(deps({ store: first }))
+
+  /* 프로세스가 새로 선 것으로 본다 — 저장본만 물려주고 판정 상태는 버린다. */
+  const saved = [...first.rows.values()].map(c => JSON.parse(JSON.stringify(c)) as StoredCommand)
+  const second = makeStore(saved)
+  const out = await runRulesOnce(deps({ store: second }))
+
+  assert.equal(out[0]!.proposed, 0)
+  assert.equal(second.rows.size, 1)
+})
+
+test('★ 결정이 끝난 것은 다시 막지 않는다 — 어제 거절한 조건이 오늘 또 성립하면 새 판단거리다', async () => {
+  const store = makeStore()
+  await runRulesOnce(deps({ store }))
+  /* 사람이 거절했다. */
+  const row = [...store.rows.values()][0]!
+  await store.save(TWIN.domainId, { ...row, state: 'rejected' })
+
+  const out = await runRulesOnce(deps({ store }))
+  assert.equal(out[0]!.proposed, 1, '거절된 것이 영구히 그 조건을 막고 있다')
+  assert.equal(store.rows.size, 2)
+})
+
+/* ── 저장소가 근거를 말하지 않으면 판정하지 않는다 ──────────────────────── */
+
+test('★ 근거를 읽을 길이 없으면 아무것도 올리지 않고 말한다 — 조용히 중복을 내지 않는다', async () => {
+  const store = makeStore()
+  delete (store as any).openCauses
+
+  const out = await runRulesOnce(deps({ store }))
+  assert.equal(out[0]!.proposed, 0)
+  assert.equal(store.rows.size, 0)
+  assert.match(out[0]!.skips[0]!.reason, /openCauses/)
+})
+
+/* ── 상태를 못 읽는 트윈 ─────────────────────────────────────────────────── */
+
+test('★ 스냅샷이 없는 트윈은 「주의 0건」이 아니다 — 멈춘 트윈을 조건 없음으로 읽지 않는다', async () => {
+  const out = await runRulesOnce(deps({ attentionsOf: () => undefined }))
+  assert.equal(out[0]!.proposed, 0)
+  assert.match(out[0]!.skips[0]!.reason, /멈춰 있거나 아직 서지 않았다/)
+})
+
+test('주의가 정말 0건이면 이유를 만들지 않는다 — 정상이다', async () => {
+  const out = await runRulesOnce(deps({ attentionsOf: () => [] }))
+  assert.equal(out[0]!.proposed, 0)
+  assert.deepEqual(out[0]!.skips, [])
+})
+
+test('규칙이 없으면 상태를 읽지도 않는다 — 아무것도 안 할 일에 값을 만들지 않는다', async () => {
+  let read = 0
+  const out = await runRulesOnce(
+    deps({
+      rulesOf: async () => [],
+      attentionsOf: () => {
+        read++
+        return []
+      }
+    })
+  )
+  assert.equal(read, 0)
+  assert.deepEqual(out[0]!.skips, [])
+})
+
+/* ── 한 트윈이 실패해도 나머지는 돈다 ───────────────────────────────────── */
+
+test('★ 한 트윈의 규칙이 터져도 다른 트윈은 돈다 — 고치는 동안 전체가 멈추지 않게', async () => {
+  const other = { domainId: 'd-1', instanceId: 'twin-b' }
+  const store = makeStore()
+  const out = await runRulesOnce(
+    deps({
+      store,
+      ownedTwins: () => [TWIN, other],
+      rulesOf: async twin => {
+        if (twin.instanceId === TWIN.instanceId) throw new Error('규칙을 읽지 못했다')
+        return [rule({ instanceId: other.instanceId })]
+      }
+    })
+  )
+
+  assert.equal(out.length, 2)
+  assert.match(String(out[0]!.failed), /규칙을 읽지 못했다/)
+  assert.equal(out[1]!.proposed, 1, '앞 트윈이 터져서 뒤 트윈이 안 돌았다')
+})
+
+test('★ 한 지시가 거절돼도 나머지는 낸다 — 그리고 거절을 삼키지 않는다', async () => {
+  const store = makeStore()
+  const out = await runRulesOnce(
+    deps({
+      store,
+      /* 하나는 선언되지 않은 종류를 가리키고, 하나는 제대로 된 것. */
+      rulesOf: async () => [rule({ id: 'bad', commandType: 'line.shutdown' }), rule({ id: 'good' })],
+      attentionsOf: () => [attention()]
+    })
+  )
+
+  assert.equal(out[0]!.proposed, 1)
+  assert.equal(out[0]!.skips.length, 1)
+  assert.match(out[0]!.skips[0]!.reason, /선언되지 않은 조치 종류/)
+})
+
+/* ── 돈 결과를 남긴다 ───────────────────────────────────────────────────── */
+
+test('★ 돈 결과를 밖으로 넘긴다 — 조용히 안 도는 규칙과 조건이 없어서 안 내는 규칙을 구별하려면 필요하다', async () => {
+  const notes: any[] = []
+  await runRulesOnce(deps({ noteRun: async (twin, report) => void notes.push({ twin, report }) }))
+
+  assert.equal(notes.length, 1)
+  assert.equal(notes[0].report.proposed, 1)
+})
+
+test('기록을 남기지 못해도 판정은 끝난 것이다 — 기록 실패로 조치를 되돌리지 않는다', async () => {
+  const store = makeStore()
+  const out = await runRulesOnce(
+    deps({ store, noteRun: async () => { throw new Error('기록 실패') } })
+  )
+  assert.equal(out[0]!.proposed, 1)
+  assert.equal(store.rows.size, 1)
+})