@things-factory/headless-twin 10.0.18 → 10.0.19

package/server/service/reference/reference-hook.ts

@@ -42,11 +42,12 @@
  * 경계가 이미 거릅니다(§`FactDeduper`) — 이 파일이 따로 하지 않습니다. 응답에 몇 건이 중복이었는지
  * 함께 알립니다.
  */
-import { getRepository } from '@things-factory/shell'
+import { WEBHOOK_STATUS, checkSequence } from '@operato/ops-contract'
 
-import { TwinReference } from './twin-reference.js'
-import { getAdapter } from './reference-adapter.js'
-import { HOOK_STATUS, producedInstance, secretFromHeaders, secretMatches, type HookOutcome } from './hook-contract.js'
+import { twinWarn } from '../../engine/log.js'
+
+import { getAdapter, type InboundBatch } from './reference-adapter.js'
+import { authorizeHook, producedInstance, pushCursorKey, seqOf, withSeq, type HookOutcome } from './hook-contract.js'
 
 /**
  * 훅 하나를 처리한다 — 찾고 · 확인하고 · 커넥터에게 옮기게 하고 · 유입으로 넘긴다.
@@ -60,16 +61,33 @@ export async function handleHook(args: {
   instanceId: string
   headers: Record<string, unknown>
   body: unknown
-  /** 레코드를 트윈에 넣는다 — 받은 수와 버린 수를 돌려준다. */
-  ingest: (instanceId: string, records: unknown[]) => { applied: number; duplicates: number; rejected: number }
+  /**
+   * 받은 바이트 그대로 — 서명을 확인하려면 이것이 있어야 한다.
+   *
+   * 파싱한 객체를 다시 문자열로 만들면 키 순서와 공백이 달라져 서명이 맞지 않는다. 없으면 서명을 쓰는
+   * 요청은 거절된다(§`authorizeHook`).
+   */
+  rawBody?: string
+  /** 서명 창을 재는 기준 시각. 부르는 쪽이 준다 — 여기서 읽으면 시험이 시계에 매인다. */
+  nowMs?: number
+  /** 레코드를 트윈에 넣는다 — 받은 수와 **떨어진 것들**을 돌려준다. */
+  ingest: (instanceId: string, records: unknown[]) => IngestResult
+  /**
+   * 저장소를 대신 쓰는 자리 — **시험이 재기동을 넣을 수 있게.**
+   *
+   * `ingest` 를 부르는 쪽이 넘겨 주는 것과 같은 이유다(위 §). 커서는 재기동을 넘어 살아야 하는데, 한
+   * 프로세스 안에서만 확인하면 「적히나」는 보이지만 「다시 세우면 읽히나」는 안 보인다. 그 둘이 갈린
+   * 결함을 이 저장소가 이미 겪었다.
+   */
+  store: HookStore
 }): Promise<HookOutcome> {
-  const { domainId, source, instanceId, headers, body, ingest } = args
+  const { domainId, source, instanceId, headers, body, rawBody, ingest } = args
+  const nowMs = args.nowMs ?? Date.now()
+  const { store } = args
 
-  const ref = await getRepository(TwinReference)
-    .findOne({ where: { domain: { id: domainId }, source } })
-    .catch(() => null)
+  const ref = await store.load(domainId, source)
   if (!ref) {
-    return { status: HOOK_STATUS.unknownTarget, body: { ok: false, error: `unknown connection "${source}"` } }
+    return { status: WEBHOOK_STATUS.unknownTarget, body: { ok: false, error: `unknown connection "${source}"` } }
   }
 
   const cfg: any = (ref as any).connectionConfig ?? {}
@@ -77,21 +95,22 @@ export async function handleHook(args: {
   if (!expected) {
     /* 비밀값을 선언하지 않은 연결은 훅을 받지 않는다 — 기본이 거부다. */
     return {
-      status: HOOK_STATUS.badSecret,
+      status: WEBHOOK_STATUS.badSecret,
       body: {
         ok: false,
         error: `connection "${source}" declares no hookSecret — set one in the connection settings before pushing to it`
       }
     }
   }
-  if (!secretMatches(secretFromHeaders(headers), expected)) {
-    return { status: HOOK_STATUS.badSecret, body: { ok: false, error: 'hook secret does not match' } }
+  const auth = authorizeHook({ headers, rawBody, secret: expected, nowMs })
+  if (auth.ok === false) {
+    return { status: WEBHOOK_STATUS.badSecret, body: { ok: false, error: auth.reason } }
   }
 
   const site = producedInstance(ref as any, instanceId)
   if (!site) {
     return {
-      status: HOOK_STATUS.unknownTarget,
+      status: WEBHOOK_STATUS.unknownTarget,
       body: { ok: false, error: `twin "${instanceId}" was not created by connection "${source}"` }
     }
   }
@@ -99,47 +118,245 @@ export async function handleHook(args: {
   const adapter: any = getAdapter(String((ref as any).adapterType ?? ''))
   if (typeof adapter?.handleInbound !== 'function') {
     return {
-      status: HOOK_STATUS.unsupported,
+      status: WEBHOOK_STATUS.unsupported,
       body: { ok: false, error: `connector "${(ref as any).adapterType}" cannot take pushed events (no handleInbound)` }
     }
   }
 
-  let records: unknown[]
+  let batch: InboundBatch
   try {
-    records = adapter.handleInbound(cfg, site, body, headers) ?? []
+    batch = adapter.handleInbound(cfg, site, body, headers)
   } catch (e: any) {
     /* 옮기지 못한 것은 그쪽 모양이 바뀐 것이다 — 다시 보내도 같으므로 재시도를 부르지 않는다. */
-    return { status: HOOK_STATUS.badPayload, body: { ok: false, error: e?.message ?? 'cannot translate the payload' } }
+    return { status: WEBHOOK_STATUS.badPayload, body: { ok: false, error: e?.message ?? 'cannot translate the payload' } }
   }
-  if (!Array.isArray(records)) {
-    return { status: HOOK_STATUS.badPayload, body: { ok: false, error: 'the connector did not return a list of records' } }
+  const items = batch?.items
+  if (!Array.isArray(items)) {
+    return {
+      status: WEBHOOK_STATUS.badPayload,
+      body: { ok: false, error: 'the connector did not return a list of items' }
+    }
   }
+
+  /*
+   * **번호 확인** — 이 자리가 프레임워크인 이유는 밀어 주는 모든 연결에 같은 규율이라야 하기 때문이다.
+   * 커넥터마다 만들면 한 곳이 빠지고, 빠진 그 연결에서만 사실이 없어진다.
+   *
+   * 번호를 매기지 않는 원본(chef · ppms)은 `seq` 를 주지 않고, 그때는 확인하지 않는다. 확인하지 않았다는
+   * 것은 응답에 남긴다 — 「확인했고 이상 없다」와 구별되어야 한다.
+   */
+  const scope = typeof batch.scope === 'string' && batch.scope.trim() ? batch.scope.trim() : undefined
+  const withSeqCount = items.filter(i => typeof i?.seq === 'number').length
+  if (withSeqCount && withSeqCount !== items.length) {
+    /* 섞이면 빠진 것이 있는지 판단할 근거가 없다. 반쯤 확인한 것을 확인했다고 말하지 않는다. */
+    return {
+      status: WEBHOOK_STATUS.badPayload,
+      body: { ok: false, error: `mixed batch — ${withSeqCount} of ${items.length} items carry a sequence number` }
+    }
+  }
+  const numbered = withSeqCount > 0 && scope !== undefined
+
+  /*
+   * **첫 구멍에서 멈춘다.** 구멍 뒤의 봉투를 받아들이면 그 구멍이 영영 메워지지 않는다 — 보내는 쪽은
+   * `expectedSeq` 부터 다시 보내고, 뒤엣것은 그때 함께 온다.
+   */
+  let take = items.length
+  let advanced: { scope: string; seq: number } | undefined
+  let gap: { expectedSeq: number; lastSeq: number } | undefined
+  if (numbered) {
+    /* 열쇠에 트윈을 넣는다 — 연결 하나가 트윈 여럿을 만들고 커서는 연결마다 한 행이다. */
+    const key = pushCursorKey(instanceId, scope as string)
+    let cursor = seqOf((ref as any).liveCursor, key)
+    take = 0
+    for (const item of items) {
+      let verdict
+      try {
+        verdict = checkSequence(cursor, item.seq as number)
+      } catch (e: any) {
+        return { status: WEBHOOK_STATUS.badPayload, body: { ok: false, error: e?.message ?? 'bad sequence number' } }
+      }
+      if (verdict.kind === 'gap') {
+        gap = { expectedSeq: verdict.expectedSeq, lastSeq: verdict.lastSeq }
+        break
+      }
+      cursor = verdict.lastSeq
+      take++
+    }
+    /* 앞의 것을 하나도 못 받았으면 커서를 올릴 것이 없다. */
+    if (take > 0 && typeof cursor === 'number') advanced = { scope: key, seq: cursor }
+  }
+
+  const records = items.slice(0, take).map(i => i.record)
+
   if (!records.length) {
-    /* 옮길 것이 없는 것은 오류가 아니다 — 그쪽이 우리와 무관한 것을 보낸 것일 수 있다. */
-    return { status: HOOK_STATUS.ok, body: { ok: true, offered: 0, applied: 0, duplicates: 0, rejected: 0 } }
+    /*
+     * 옮길 것이 없는 것은 오류가 아니다 — 그쪽이 우리와 무관한 것을 보낸 것일 수 있다. 다만 첫 봉투부터
+     * 구멍이면 그것은 받은 것이 없는 것이고, 그 앞부터 달라고 해야 한다.
+     */
+    if (gap) return gapOutcome(scope, gap)
+    if (advanced) await saveSeq(store, ref as any, advanced.scope, advanced.seq)
+    return {
+      status: WEBHOOK_STATUS.ok,
+      body: { ok: true, offered: 0, applied: 0, duplicates: 0, rejected: [], ...seqBody(scope, advanced, numbered) }
+    }
   }
 
-  let result: { applied: number; duplicates: number; rejected: number }
+  let result: IngestResult
   try {
     result = ingest(instanceId, records)
   } catch (e: any) {
-    return { status: HOOK_STATUS.failed, body: { ok: false, error: e?.message ?? 'ingest failed' } }
+    return { status: WEBHOOK_STATUS.failed, body: { ok: false, error: e?.message ?? 'ingest failed' } }
   }
+  const rejected = result.rejected ?? []
 
-  if (result.applied === 0 && result.duplicates === 0 && records.length > 0 && result.rejected === 0) {
+  if (result.applied === 0 && result.duplicates === 0 && rejected.length === 0) {
     /*
      * 넣었는데 한 건도 반영되지 않았고 중복도 거부도 아니면, 그 트윈이 실시간으로 돌지 않는 것이다.
-     * 200 을 주면 그쪽은 전달된 줄 알고 그 사실을 버린다. 그래서 재시도로 풀리지 않는다는 것을 코드로
-     * 말한다 — 사람이 트윈을 띄워야 한다.
+     * 200 을 주면 그쪽은 전달된 줄 알고 그 사실을 버린다.
+     *
+     * **커서를 올리지 않는다.** 한 건도 안 들어갔는데 번호를 올리면 그 번호는 다시 오지 않고, 트윈이
+     * 뜬 뒤에 그 구간이 비어 있게 된다.
      */
     return {
-      status: HOOK_STATUS.notLive,
-      body: { ok: false, error: `twin "${instanceId}" is not running live — nothing was applied`, offered: records.length }
+      status: WEBHOOK_STATUS.notLive,
+      body: {
+        ok: false,
+        error: `twin "${instanceId}" is not running live — nothing was applied`,
+        offered: records.length,
+        retryAfterMs: NOT_LIVE_RETRY_MS
+      }
+    }
+  }
+
+  if (advanced) await saveSeq(store, ref as any, advanced.scope, advanced.seq)
+
+  /*
+   * **구멍이 있으면 그것이 답을 정한다.** 앞의 것은 이미 들어갔으므로 `lastSeq` 까지는 보냄으로 표시하게
+   * 하고, 떨어진 것이 있으면 그것도 함께 싣는다 — 두 소식이 한 응답에 들어가야 보내는 쪽이 둘 다 한다.
+   */
+  if (gap) return gapOutcome(scope, gap, rejected, advanced)
+
+  if (rejected.length) {
+    /*
+     * **다시 보내라고 하지 않는다.** 떨어진 것은 모양이 틀린 것이라 같은 것을 다시 보내도 또 떨어지고,
+     * 함께 간 나머지는 이미 들어갔으므로 두 번 들어간다.
+     */
+    return {
+      status: WEBHOOK_STATUS.partial,
+      body: {
+        ok: false,
+        error: `${rejected.length} of ${records.length} records did not pass validation`,
+        offered: records.length,
+        applied: result.applied,
+        duplicates: result.duplicates,
+        rejected,
+        ...seqBody(scope, advanced, numbered)
+      }
     }
   }
 
   return {
-    status: HOOK_STATUS.ok,
-    body: { ok: true, offered: records.length, applied: result.applied, duplicates: result.duplicates, rejected: result.rejected }
+    status: WEBHOOK_STATUS.ok,
+    body: {
+      ok: true,
+      offered: records.length,
+      applied: result.applied,
+      duplicates: result.duplicates,
+      rejected: [],
+      ...seqBody(scope, advanced, numbered)
+    }
   }
 }
+
+/**
+ * 유입이 돌려주는 것.
+ *
+ * 떨어진 것을 **수가 아니라 목록으로** 받는다. 수만 받으면 보내는 쪽에 「몇 건이 떨어졌다」밖에 말할 수
+ * 없고, 그러면 무엇을 따로 두어야 할지 알 수 없어 배치 전체를 다시 보내거나 전부 버린다.
+ */
+export interface IngestResult {
+  applied: number
+  duplicates: number
+  rejected: { record: unknown; errors: string[] }[]
+}
+
+/**
+ * 구멍을 알리는 응답 — **앞의 것은 받았다는 것을 함께 말한다.**
+ *
+ * `lastSeq` 를 빼면 보내는 쪽은 이미 들어간 것까지 다시 보내고, 그것이 매번 중복으로 걸러지면서
+ * 처리량만 먹는다.
+ */
+function gapOutcome(
+  scope: string | undefined,
+  gap: { expectedSeq: number; lastSeq: number },
+  rejected: { record: unknown; errors: string[] }[] = [],
+  advanced?: { scope: string; seq: number }
+): HookOutcome {
+  return {
+    status: WEBHOOK_STATUS.sequenceGap,
+    body: {
+      ok: false,
+      error: 'sequence gap',
+      scope,
+      expectedSeq: gap.expectedSeq,
+      lastSeq: advanced?.seq ?? gap.lastSeq,
+      ...(rejected.length ? { rejected } : {})
+    }
+  }
+}
+
+/**
+ * 트윈이 안 돌 때 얼마나 쉬라고 할 것인가.
+ *
+ * 사람이 트윈을 띄워야 풀리므로 초 단위로 다시 두드릴 이유가 없다. 그렇다고 길게 잡으면 트윈이 뜬 뒤
+ * 그만큼 늦게 이어진다.
+ */
+const NOT_LIVE_RETRY_MS = 30_000
+
+/**
+ * 응답에 번호를 어떻게 적나 — **확인한 것과 확인하지 않은 것을 구별한다.**
+ *
+ * 번호를 매기지 않는 원본은 확인할 것이 없다. 그것을 응답에서 「이상 없다」와 같아 보이게 두면, 어느
+ * 연결이 연속성을 지키고 있는지 아무도 알 수 없다.
+ */
+function seqBody(
+  scope: string | undefined,
+  advanced: { scope: string; seq: number } | undefined,
+  numbered: boolean
+): Record<string, unknown> {
+  if (!numbered) return { sequenceChecked: false }
+  return { sequenceChecked: true, scope, lastSeq: advanced?.seq }
+}
+
+/**
+ * 커서에 번호를 적는다 — **반영한 뒤에만.**
+ *
+ * 넣기 전에 올리면, 넣다가 실패했을 때 그 번호는 다시 오지 않는다. 보내는 쪽은 200 을 못 받았으니 다시
+ * 보내겠지만, 그때는 커서가 이미 지나가 있어 `behind` 로 읽히고 버려진다.
+ *
+ * 적지 못하는 것은 사실 유입을 무르는 이유가 아니다 — 이미 들어간 사실은 그대로 두고, 다음 번호가 오면
+ * `gap` 으로 드러난다. 그래서 실패를 던지지 않고 남긴다.
+ */
+async function saveSeq(
+  store: HookStore,
+  ref: { id: string; liveCursor?: unknown },
+  scope: string,
+  seq: number
+): Promise<void> {
+  const next = withSeq(ref.liveCursor, scope, seq)
+  ref.liveCursor = next
+  await store
+    .saveCursor(ref.id, next)
+    .catch(err => twinWarn(`[twin-hook] 번호를 커서에 적지 못했다 (${scope}=${seq}) — ${err?.message ?? err}`))
+}
+
+/**
+ * 훅이 저장소에 닿는 두 자리 — 연결을 찾는 것과 커서를 적는 것.
+ *
+ * 이 둘만 밖으로 낸다. 나머지는 인자만 보고 답하므로 시험이 데이터베이스를 세우지 않아도 된다.
+ */
+export interface HookStore {
+  load(domainId: string, source: string): Promise<any | null>
+  saveCursor(refId: string, cursor: unknown): Promise<void>
+}
+

package/test/actuation-dispatch.test.ts

@@ -0,0 +1,196 @@
+/*
+ * **승인을 지나지 않은 조치는 현장에 나가지 못한다** — 배선.
+ *
+ * ── 왜 배선을 따로 보나 (2026-08-31) ─────────────────────────────────────
+ * 승인 판정 자체는 계약이 지킨다(`ops-contract/test/actuation-gate.test.ts`). 여기서 보는 것은
+ * **그 판정이 실제 경로에 서 있는가**다 — 어댑터가 불렸는가, 상태가 적혔는가, 다시 세운 뒤에도 승인이
+ * 남아 있는가.
+ *
+ * 이 저장소에서 가장 자주 나는 결함이 「자리는 있고 길이 없다」이고, 게이트가 그 부류로 나면 결과가
+ * 현장의 작업지시다. 그래서 마지막 시험이 **저장본만 남기고 다시 세운다.**
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import type { TwinCommand } from '@operato/ops-contract'
+
+import { approve, dispatch, reject, type CommandAck, type CommandStore } from '../server/service/actuation/command-dispatcher.js'
+
+const DOMAIN = 'd-1'
+const AT = '2026-08-31T02:00:00.000Z'
+const APPROVAL = { by: 'line-lead', at: AT }
+
+const irreversible = (over: Partial<TwinCommand> = {}): TwinCommand => ({
+  id: 'cmd-1',
+  instanceId: 'twin-a',
+  type: 'order.hold',
+  origin: 'ai',
+  proposedAt: AT,
+  state: 'proposed',
+  ...over
+})
+
+/** 저장본 하나 — 프로세스가 아니라 여기 산다. 그래서 다시 세워도 남는다. */
+function makeStore(initial: TwinCommand): CommandStore & { rows: Map<string, TwinCommand> } {
+  const rows = new Map<string, TwinCommand>([[initial.id, initial]])
+  return {
+    rows,
+    load: async (domainId, id) => (domainId === DOMAIN ? (rows.get(id) ?? null) : null),
+    /* 저장소를 흉내 내는 것이라 복사해 넣는다 — 같은 객체면 안 적혀도 통과한다. */
+    save: async (domainId, command) => {
+      assert.equal(domainId, DOMAIN)
+      rows.set(command.id, JSON.parse(JSON.stringify(command)))
+    }
+  }
+}
+
+const ok = (ref = 'JOB-1') => async (): Promise<CommandAck> => ({ ok: true, ref })
+
+/* ── 승인 없이는 나가지 못한다 ────────────────────────────────────────────── */
+
+test('★ 승인하지 않은 조치는 어댑터에 닿지 않는다', async () => {
+  const store = makeStore(irreversible())
+  let called = false
+
+  await assert.rejects(
+    dispatch(store, DOMAIN, 'cmd-1', async () => {
+      called = true
+      return { ok: true }
+    }),
+    /승인되지 않은/
+  )
+  assert.equal(called, false, '어댑터가 불렸다 — 게이트가 서지 않았다')
+  assert.equal(store.rows.get('cmd-1')!.state, 'proposed', '상태가 움직였다')
+})
+
+test('★ 상태만 approved 로 적고 승인 기록이 없으면 막는다 — 저장본을 손으로 고쳐도 열리지 않는다', async () => {
+  const store = makeStore(irreversible({ state: 'approved' }))
+  let called = false
+  await assert.rejects(
+    dispatch(store, DOMAIN, 'cmd-1', async () => {
+      called = true
+      return { ok: true }
+    }),
+    /승인 기록이 없는/
+  )
+  assert.equal(called, false)
+})
+
+test('★ 승인하면 나간다 — 어댑터가 돌려준 것이 남는다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+  const settled = await dispatch(store, DOMAIN, 'cmd-1', ok('JOB-77'))
+
+  assert.equal(settled.state, 'acked')
+  assert.equal(settled.dispatchRef, 'JOB-77', '되돌릴 때 무엇을 되돌릴지 말할 수 없게 된다')
+  assert.equal(store.rows.get('cmd-1')!.approval?.by, 'line-lead')
+})
+
+test('★ 넘기기 전에 「넘기는 중」을 먼저 적는다 — 그 사이에 죽으면 현장이 두 번 움직인다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+
+  let seenWhileDispatching: string | undefined
+  await dispatch(store, DOMAIN, 'cmd-1', async () => {
+    seenWhileDispatching = store.rows.get('cmd-1')!.state
+    return { ok: true, ref: 'x' }
+  })
+  assert.equal(seenWhileDispatching, 'dispatched', '어댑터를 부르는 동안 저장본이 아직 approved 였다')
+})
+
+/* ── 되돌릴 수 있는 것의 다른 문 ─────────────────────────────────────────── */
+
+test('★ 되돌릴 수 있는 조치는 사람 없이 지난다 — 시뮬과 what-if 가 이 길이다', async () => {
+  const store = makeStore(irreversible({ reversible: true }))
+  const settled = await dispatch(store, DOMAIN, 'cmd-1', ok())
+  assert.equal(settled.state, 'acked')
+})
+
+test('★ 되돌릴 수 있다고 적지 않은 것은 그 문으로 못 간다 — 모름을 통과로 읽지 않는다', async () => {
+  const store = makeStore(irreversible({ reversible: false }))
+  await assert.rejects(dispatch(store, DOMAIN, 'cmd-1', ok()))
+})
+
+/* ── 실패와 되풀이 ────────────────────────────────────────────────────────── */
+
+test('★ 어댑터가 던지면 실패로 남고 이유가 적힌다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+  const settled = await dispatch(store, DOMAIN, 'cmd-1', async () => {
+    throw new Error('MES 가 응답하지 않는다')
+  })
+
+  assert.equal(settled.state, 'failed')
+  assert.match(String(settled.error), /응답하지 않는다/)
+})
+
+test('어댑터가 이유 없이 실패해도 빈 칸으로 두지 않는다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+  const settled = await dispatch(store, DOMAIN, 'cmd-1', async () => ({ ok: false }))
+  assert.ok(String(settled.error).length > 0)
+})
+
+test('★ 실패한 것은 다시 넘길 수 있다 — 승인을 다시 받지 않는다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+  await dispatch(store, DOMAIN, 'cmd-1', async () => ({ ok: false, error: '잠시 끊겼다' }))
+
+  const retried = await dispatch(store, DOMAIN, 'cmd-1', ok('JOB-9'))
+  assert.equal(retried.state, 'acked')
+  assert.equal(retried.dispatchRef, 'JOB-9')
+})
+
+test('★ 이미 답을 받은 것은 다시 나가지 않는다 — 두 번 나가면 현장이 두 번 움직인다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+  await dispatch(store, DOMAIN, 'cmd-1', ok())
+
+  await assert.rejects(dispatch(store, DOMAIN, 'cmd-1', ok()), /넘길 수 없다/)
+})
+
+/* ── 거절 ─────────────────────────────────────────────────────────────────── */
+
+test('★ 거절하면 끝이다 — 되살아나지 않는다', async () => {
+  const store = makeStore(irreversible())
+  await reject(store, DOMAIN, 'cmd-1', { by: 'line-lead', at: AT, note: '지금 그 라인은 정지 중' })
+
+  assert.equal(store.rows.get('cmd-1')!.state, 'rejected')
+  await assert.rejects(approve(store, DOMAIN, 'cmd-1', APPROVAL))
+  await assert.rejects(dispatch(store, DOMAIN, 'cmd-1', ok()))
+})
+
+test('승인을 기다리는 중에도 거절할 수 있다', async () => {
+  const store = makeStore(irreversible())
+  await approve(store, DOMAIN, 'cmd-1', APPROVAL)
+  await reject(store, DOMAIN, 'cmd-1', { by: 'plant-manager', at: AT })
+  assert.equal(store.rows.get('cmd-1')!.state, 'rejected')
+})
+
+/* ── 재기동 ───────────────────────────────────────────────────────────────── */
+
+test('★ 승인이 재기동을 넘어 산다 — 사람이 승인한 것이 사라지면 안 된다', async () => {
+  const first = makeStore(irreversible())
+  await approve(first, DOMAIN, 'cmd-1', APPROVAL)
+  const saved: TwinCommand = JSON.parse(JSON.stringify(first.rows.get('cmd-1')))
+
+  /* 프로세스가 새로 선 것으로 본다 — 앞의 저장소 객체는 버리고 저장본만 물려준다. */
+  const second = makeStore(saved)
+  const settled = await dispatch(second, DOMAIN, 'cmd-1', ok('JOB-3'))
+
+  assert.equal(settled.state, 'acked', '이어받지 못하면 승인이 사라져 던진다')
+  assert.equal(settled.approval?.by, 'line-lead')
+})
+
+test('★ 재기동이 게이트를 열지 않는다 — 되세운 것도 같은 문을 지난다', async () => {
+  /* JSON 에는 승인 표식이 없다. 되세울 때 표식을 그냥 붙이면 재기동이 곧 우회로가 된다. */
+  const saved: TwinCommand = JSON.parse(JSON.stringify(irreversible()))
+  const store = makeStore(saved)
+  await assert.rejects(dispatch(store, DOMAIN, 'cmd-1', ok()), /승인되지 않은/)
+})
+
+test('모르는 커맨드는 조용히 넘어가지 않는다', async () => {
+  const store = makeStore(irreversible())
+  await assert.rejects(dispatch(store, DOMAIN, 'nope', ok()), /모르는 커맨드/)
+  await assert.rejects(approve(store, DOMAIN, 'nope', APPROVAL), /모르는 커맨드/)
+})