@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/rejection-carries-event-id.test.ts

@@ -1,101 +0,0 @@
-/*
- * A refusal has to name which envelope was refused.
- *
- * ── What this catches, and why the existing test did not (2026-09-08) ──────
- * `rejectedForCaller` pairs a refused record with its envelope by **object identity** — value
- * comparison would let two identically shaped records take each other's id. Its own test
- * hands the same object to both sides, so it passes and proves the pairing works.
- *
- * It does not prove anything about the real path, because in between
- * `ingestCanonicalRecords` builds `{ ...r, eventTime, sourceType }` — **a new object**. The
- * refusal then carries that copy, the copy is not in the identity map, and the response comes
- * back as `{ record, errors }` with no `eventId`:
- *
- *     sent   {"eventId":"probe-eventid-check-001","record":{"kind":"transformation"}}
- *     back   rejected: [{ record: {kind:"transformation", sourceType:"twin"}, errors:[…] }]
- *
- * The sending side cannot mark the row that was refused, so it cannot settle the batch and
- * its queue stops moving — measured on the plant side as 719 envelopes pending with nothing
- * lost and nothing advancing.
- *
- * So this test walks the seam the way a real envelope does: through the ingest that makes the
- * copy, then through the pairing. That is the step a pure test of either half cannot take.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ingestCanonicalRecords } from '../server/engine/canonical-ingest.js'
-import { rejectedForCaller } from '../server/service/reference/hook-rejected.js'
-
-const AT = '2026-09-08T02:00:00.000Z'
-
-/** A transformation the kernel refuses — no inputs, no outputs, no bizStep. */
-const REFUSED = { kind: 'transformation' } as any
-
-test('a refusal names the envelope it came from, after ingest has copied the record', () => {
-  /* The envelope as the hook holds it: the record object, and the id that identifies its row. */
-  const items = [{ record: REFUSED, eventId: 'evt-refused-1' }]
-
-  const result = ingestCanonicalRecords(
-    items.map(i => i.record),
-    'test-domain',
-    AT
-  ) as any
-
-  assert.equal(result.rejected.length, 1, 'the kernel refuses this record')
-
-  const forCaller = rejectedForCaller(result.rejected, items)
-
-  assert.deepEqual(
-    forCaller.map((r: any) => r.eventId),
-    ['evt-refused-1'],
-    'the refusal carries the envelope id — without it the sender cannot mark the row'
-  )
-})
-
-test('two refused records of the same shape keep their own ids', () => {
-  /*
-   * This is why the pairing is by identity and not by value. Both records look the same, and
-   * value comparison would hand the first id to both — the sender would mark one row twice
-   * and leave the other pending forever.
-   */
-  const a = { kind: 'transformation' } as any
-  const b = { kind: 'transformation' } as any
-  const items = [
-    { record: a, eventId: 'evt-a' },
-    { record: b, eventId: 'evt-b' }
-  ]
-
-  const result = ingestCanonicalRecords(
-    items.map(i => i.record),
-    'test-domain',
-    AT
-  ) as any
-  const forCaller = rejectedForCaller(result.rejected, items)
-
-  assert.deepEqual(
-    forCaller.map((r: any) => r.eventId).sort(),
-    ['evt-a', 'evt-b'],
-    'each refusal keeps its own id'
-  )
-})
-
-test('an envelope with no id still says what was refused', () => {
-  /*
-   * A connector that does not number its envelopes gets the record back instead. An empty id
-   * would be worse than none: the sender would look for a row, find nothing, and treat the
-   * batch as understood.
-   */
-  const items = [{ record: REFUSED }]
-
-  const result = ingestCanonicalRecords(
-    items.map(i => i.record),
-    'test-domain',
-    AT
-  ) as any
-  const forCaller = rejectedForCaller(result.rejected, items) as any[]
-
-  assert.equal(forCaller.length, 1)
-  assert.equal('eventId' in forCaller[0], false, 'no id is sent rather than an empty one')
-  assert.ok('record' in forCaller[0], 'the record is sent so a person can see what was dropped')
-})

package/test/rename-twin.test.ts

@@ -1,89 +0,0 @@
-/*
- * ★ 트윈이 첫날의 이름에 갇혀 있었다 — 바꿀 문이 없었다.
- *
- * 이름은 처음 세울 때 한 번 정해지고(`provision`) 다시 읽기는 건드리지 않는다. 그 자체는 안전하다 —
- * 사람이 붙인 이름을 연결이 덮어쓰면 안 된다. 그런데 그래서 첫날 이름에서 벗어날 길이 없었다.
- *
- * 실제로 그런 일이 났다(2026-08-25 · 태양광 발전소). 커넥터가 처음 아는 이름이 연결된 시스템의
- * 코드뿐이었다.
- *
- *   현장 이름   호현에너지
- *   트윈 이름   ES202307202202      ← 화면의 트윈 목록에 이렇게 보였다
- *
- * 뒤에 사람이 부르는 이름이 어디 있는지 알아내 커넥터를 고쳤는데, 트윈 이름은 그대로였다. 남은
- * 유일한 길이 트윈을 지우고 다시 세우는 것이었고, 그러면 그날 실제 발전소에서 받은 246건이
- * 사라진다 — **이름 하나 때문에 사실을 버리는 선택**이다.
- *
- * 연결된 시스템을 따라가는 트윈에서는 이름이 나중에 좋아진다. 커넥터가 나아질 때마다 나는 일이다.
- *
- * 이 테스트는 소스를 전수 조회해 규율을 지킨다(실제 뮤테이션은 DB 와 도메인 맥락이 필요하다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-const FILE = join(import.meta.dirname, '..', 'server', 'service', 'twin-lifecycle', 'twin-lifecycle-mutation.ts')
-const src = readFileSync(FILE, 'utf8')
-const body = (() => {
-  const at = src.indexOf('async renameTwinInstance')
-  assert.ok(at > 0, '이름을 바꾸는 문이 있어야 한다')
-  /*
-   * **주석을 걷고 본다.** 이 조각은 다음 문(`deleteTwinInstance`)의 머리 주석까지 품는데, 그 주석은
-   * 삭제가 왜 `TwinEngine.remove` 를 부르는지 설명한다. 걷지 않으면 그 산문이 세어져, 이름 바꾸기가
-   * 런타임을 건드린다고 읽힌다 — 실제로 그렇게 빨개졌다. 세는 것은 코드지 그 옆의 글이 아니다.
-   */
-  return src
-    .slice(at, src.indexOf('async deleteTwinInstance'))
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .replace(/\/\/[^\n]*/g, '')
-})()
-
-test('★ 이름을 바꾸는 문이 있다 — 없어서 지우고 다시 세우는 것이 유일한 길이었다', () => {
-  assert.ok(/@Mutation/.test(src.slice(0, src.indexOf('async renameTwinInstance'))))
-  assert.ok(/@Arg\('instanceId'\)/.test(body))
-  assert.ok(/@Arg\('name'\)/.test(body))
-})
-
-test('★ 빈 이름은 받지 않는다 — 지우는 것과 바꾸는 것은 다른 일이다', () => {
-  assert.ok(/\.trim\(\)/.test(body), '앞뒤 공백은 이름이 아니다')
-  assert.ok(/if \(!next\) throw/.test(body), '빈 값이면 거절한다')
-  /* 빈 이름을 받아 두면 그 트윈은 목록에서 식별자만 남는데, 그것을 「바꿨다」로 보고하면 거짓이다. */
-  assert.ok(/left as it was/.test(body), '무엇도 바뀌지 않았다는 것을 말한다')
-})
-
-test('★ 남의 도메인 트윈은 바꾸지 못한다 — 테넌트 격리', () => {
-  assert.ok(/where: \{ domain: \{ id: domainId \}, instanceId \}/.test(body), '도메인으로 좁혀 찾는다')
-  assert.ok(/unknown twin/.test(body), '없으면 이유를 말한다')
-})
-
-test('바꾸지 않은 경우를 바꿨다고 말하지 않는다', () => {
-  assert.ok(/changed: false/.test(body), '같은 이름이면 changed 를 false 로 낸다')
-  assert.ok(/previous/.test(body), '무엇에서 무엇으로 바뀌었는지 함께 낸다')
-})
-
-test('바꾼 사람을 남긴다 — 이름은 사람이 하는 선언이다', () => {
-  assert.ok(/updater: context\.state\.user/.test(body))
-})
-
-test('이름만 바꾼다 — 트윈을 멈추거나 다시 읽지 않는다', () => {
-  /*
-   * 도는 런타임은 식별자로 동작하고 이름을 쓰지 않는다. 정지·기동을 끼우면 그 사이의 사실이 어디로
-   * 갔는지 설명해야 하는데, 이름 때문에 그 값을 치를 이유가 없다.
-   */
-  assert.ok(!/TwinEngine\.(stop|start|remove|resync)/.test(body), '런타임을 건드리지 않는다')
-  assert.ok(!/adoptStructure|reprovision/.test(body), '구조를 다시 읽지 않는다')
-})
-
-test('연결된 시스템이 이름을 덮어쓰지는 않는다 — 다시 읽기는 그대로다', () => {
-  /*
-   * 「사람이 손대지 않았으면 따라간다」가 옳아 보이지만, 그러려면 「손댔다」는 표시를 새로 만들어야
-   * 한다. 이름 하나 때문에 지기에 무거운 빚이므로 사람이 바꾸는 길만 낸다. 그 결정을 여기서 고정한다.
-   *
-   * 이름을 정하는 자리는 **처음 세울 때 하나**다. 그 수가 늘면 다시 읽기가 이름을 다시 정하기
-   * 시작했다는 뜻이고, 그때는 이 결정을 다시 해야 한다.
-   */
-  const engine = readFileSync(join(import.meta.dirname, '..', 'server', 'engine', 'twin-engine.ts'), 'utf8')
-  const places = engine.match(/name: master\.siteName/g) ?? []
-  assert.equal(places.length, 1, `이름을 정하는 자리가 ${places.length}곳이다 — 처음 세울 때 하나여야 한다`)
-})

package/test/resolve-ts-siblings.mjs

@@ -1,52 +0,0 @@
-/*
- * ★ 소스 시험이 형제 모듈을 부를 수 있게 한다 — **`operato-twin` 의 같은 규칙을 이 패키지에도 둔다** — **`.js` 로 적힌 상대 경로를 `.ts` 로 되짚는다.**
- *
- * ── 무엇이 서고 있었나 (2026-08-22) ─────────────────────────────────────────
- * 이 패키지의 `npm test` 는 `node --test test/*.test.ts` 로 **소스를 그대로 실행**한다. 그런데 서버
- * 소스는 tsc 로 빌드되는 코드이므로 상대 import 를 `'./x.js'` 로 적는다(그것이 빌드 산출물에서 맞는
- * 경로다). 타입만 지우는 실행은 그 `.js` 를 `.ts` 로 바꿔 주지 않는다.
- *
- * 그래서 **소스 모듈이 형제 모듈을 값으로 참조하는 순간** 그 모듈 그래프를 부르는 시험이 전부 선다.
- * 실측으로 하루에 네 종류가 이 벽에 걸렸다: `identity/namespace.js`(정체성 이름공간) ·
- * `engine/log.js`(로그 문) · `isa95-coverage.js`(적합성 판정) · `journal-count.js`(저널 세기). 늘 같은 오류다.
- *
- *   Cannot find module '…/server/identity/namespace.js' imported from '…/templates/wms-unit-load.ts'
- *
- * ── 왜 이 방식인가 ──────────────────────────────────────────────────────────
- * 고르던 길이 둘 있었다.
- *
- *  ① 그 시험들을 **빌드 산출물**(`dist-server`)로 돌린다 — 이 패키지에 전례가 있다. 그러나 시험마다
- *     그 배선을 적어야 하고, 걸리는 시험이 늘 때마다 같은 일을 다시 한다. 그리고 산출물이 낡으면
- *     **고친 코드가 아닌 것이 돌면서 초록으로 보인다.**
- *  ② 상수를 쓰는 파일 안으로 옮긴다 — 값 참조가 사라지지만 **정본이 흩어진다.** 그것이 이 상수를 한
- *     자리에 모은 이유와 정면으로 어긋난다.
- *
- * 둘 다 증상을 피하는 것이고, 원인은 **해석 규칙 하나**다. 그래서 규칙을 고친다: 상대 경로 `.js` 가
- * 없고 같은 이름의 `.ts` 가 있으면 그것을 쓴다. 한 자리에 두므로 걸리는 시험이 늘어도 할 일이 없다.
- *
- * ── 무엇을 하지 않는가 ─────────────────────────────────────────────────────
- * **패키지 이름(`@things-factory/…`)은 손대지 않는다.** 그것은 의존 패키지의 산출물을 가리키는
- * 것이고 실제로 `.js` 가 있다. 되짚는 것은 **상대 경로**뿐이고, 그것도 `.ts` 가 실제로 있을 때만이다 —
- * 없으면 원래 오류가 그대로 난다(없는 것을 지어내지 않는다).
- */
-import { registerHooks } from 'node:module'
-import { existsSync } from 'node:fs'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-
-registerHooks({
-  resolve(specifier, context, nextResolve) {
-    /* 상대 경로의 `.js` 만 본다 — 패키지 이름과 그 밖의 확장자는 그대로 둔다. */
-    if (!specifier.startsWith('.') || !specifier.endsWith('.js')) return nextResolve(specifier, context)
-
-    try {
-      return nextResolve(specifier, context)
-    } catch (err) {
-      /* 해석이 실패한 그때만 `.ts` 를 본다 — 성공하는 경로의 뜻을 바꾸지 않는다. */
-      const parent = context?.parentURL
-      if (!parent) throw err
-      const asTs = new URL(specifier.slice(0, -3) + '.ts', parent)
-      if (!existsSync(fileURLToPath(asTs))) throw err
-      return { url: pathToFileURL(fileURLToPath(asTs)).href, shortCircuit: true, format: 'module-typescript' }
-    }
-  }
-})

package/test/restart-policy.test.ts

@@ -1,111 +0,0 @@
-/*
- * **재기동 정책** — 개명(ADR-0029 §2)과 그 규율 둘.
- *
- * ── 무엇을 바꿨나 ───────────────────────────────────────────────────────────
- * `realityMode`(`mirror`·`sim-world`·`sim-experiment`) → `restartPolicy`(`resync`·`resume`·`reset`).
- * 「현실이 어디서 오나」는 ADR-0029 가 **원본의 종류**로 옮긴 물음이고, 코드가 이 축으로 실제로 가른 것은
- * **재기동 거동 하나**였다 — 그것은 원본의 성질이 아니라 트윈과 자기 과거의 관계다. 그래서 축은 남고
- * 이름이 바뀌었다.
- *
- * ── 지키는 규율 둘 (계획서 §6) ──────────────────────────────────────────────
- * ① **모르는 값은 오류를 낸다.** 예전에는 미선언이 알리지 않고 `sim-experiment`(=저널 초기화)로 떨어졌다 — 값이
- *    하나 어긋나는 순간 이력을 지우는 길이다. 기본값을 없앴다.
- * ② **옛 어휘를 번역하지 않는다.** 번역을 두면 옛 값이 살아남고 다시 저장된다. 저장된 값은 한 번
- *    옮기고(데이터 이관), 코드는 새 어휘만 안다 — 다만 무엇으로 옮겨야 하는지는 오류 문장이 말한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { join } from 'node:path'
-
-import { readRestartPolicy, isRestartPolicy, RESTART_POLICIES } from '../server/engine/restart-policy.ts'
-
-test('셋뿐이다 — 그리고 그 셋을 읽는다', () => {
-  assert.deepEqual([...RESTART_POLICIES], ['resync', 'resume', 'reset'])
-  for (const p of RESTART_POLICIES) assert.equal(readRestartPolicy(p, 'test'), p)
-  assert.equal(readRestartPolicy('  resume  ', 'test'), 'resume', '공백은 다듬는다')
-})
-
-test('미선언은 오류를 낸다 — 기본값으로 메우면 저널이 지워지는 길이 열린다', () => {
-  for (const raw of [undefined, null, '', '   ', 42, {}]) {
-    assert.throws(() => readRestartPolicy(raw, 'twin "x"'), /twin "x": restart policy/)
-  }
-  /* 무엇을 해야 하는지 문장이 말한다 — 코드를 그대로 오류를 내지 않는다. */
-  try {
-    readRestartPolicy(undefined, 'twin "x"')
-    assert.fail('오류를 내어야 한다')
-  } catch (e: any) {
-    assert.match(e.message, /resync \| resume \| reset/)
-    assert.match(e.message, /no default/)
-  }
-})
-
-test('옛 어휘도 오류를 낸다 — 다만 무엇으로 옮길지 말한다(번역해 주지 않는다)', () => {
-  const cases: [string, string][] = [
-    ['mirror', 'resync'],
-    ['sim-world', 'resume'],
-    ['sim-experiment', 'reset']
-  ]
-  for (const [old, next] of cases) {
-    try {
-      readRestartPolicy(old, 'twin "x"')
-      assert.fail(`${old} 은 오류를 내어야 한다`)
-    } catch (e: any) {
-      assert.match(e.message, /old vocabulary/)
-      assert.match(e.message, new RegExp(`"${next}"`), '옮길 값을 말한다')
-    }
-  }
-})
-
-test('묻는 자리도 있다 — 화면·검사는 오류를 내지 않고 판별한다', () => {
-  assert.equal(isRestartPolicy('resume'), true)
-  assert.equal(isRestartPolicy('sim-world'), false)
-  assert.equal(isRestartPolicy(undefined), false)
-})
-
-/*
- * ── 옛 어휘가 코드로 되돌아오지 않게 (계획서 §6 의 검사) ────────────────────
- * ADR-0034 의 `local-declarations.test.ts` 가 `site*` 에 대해 하는 것과 같은 방식이다. 개명은 저장값·타입·
- * 화면에 걸쳐 있어서, 한 곳만 되돌아와도 그 자리가 알리지 않고 다르게 재기동한다.
- */
-const OLD_TOKENS = [/\brealityMode\b/, /\bRealityMode\b/, /'sim-world'/, /'sim-experiment'/, /DEFAULT_REALITY_MODE/]
-
-function sources(root: string): { file: string; src: string }[] {
-  const base = fileURLToPath(new URL(root, import.meta.url))
-  const out: { file: string; src: string }[] = []
-  const walk = (dir: string) => {
-    for (const name of readdirSync(dir)) {
-      if (name === 'node_modules' || name.startsWith('dist')) continue
-      const path = join(dir, name)
-      if (statSync(path).isDirectory()) { walk(path); continue }
-      if (name.endsWith('.ts')) out.push({ file: path.slice(base.length + 1), src: readFileSync(path, 'utf-8') })
-    }
-  }
-  walk(base)
-  return out
-}
-
-test('옛 어휘가 코드에 없다 — 이력을 설명하는 주석만 예외다', () => {
-  const offenders: string[] = []
-  for (const { file, src } of [...sources('../server'), ...sources('../test')]) {
-    /* 이력 설명(「예전에는 …」)과 이관 안내(restart-policy.ts)는 남아야 한다 — 그것이 개명의 근거다. */
-    if (file.endsWith('restart-policy.ts') || file.endsWith('restart-policy.test.ts')) continue
-    for (const line of src.split('\n')) {
-      const isComment = /^\s*(\*|\/\/|\/\*)/.test(line)
-      if (isComment) continue
-      if (OLD_TOKENS.some(re => re.test(line))) offenders.push(`${file}: ${line.trim().slice(0, 80)}`)
-    }
-  }
-  assert.deepEqual(offenders, [], `옛 어휘가 코드로 돌아왔다:\n${offenders.join('\n')}`)
-})
-
-test('기본값 상수가 없다 — 미선언을 우리가 고르지 않는다', () => {
-  const engine = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const code = engine
-    .split('\n')
-    .filter(line => !/^\s*(\*|\/\/|\/\*)/.test(line))
-    .join('\n')
-  assert.equal(/DEFAULT_RESTART_POLICY/.test(code), false, '기본값 상수가 되살아나면 미선언이 다시 들어온 것이 없어진다')
-  assert.match(code, /readRestartPolicy\(/, '읽는 자리는 엄격한 리더를 지난다')
-})

package/test/resync-origin-site.test.ts

@@ -1,83 +0,0 @@
-/*
- * 다시 읽기가 **자기 사이트**를 찾는가 — 사이트가 여럿인 참조에서 온 트윈의 재동기.
- *
- * ── 무엇이 났나 (2026-08-18 실측) ───────────────────────────────────────────
- * `resyncTwin` 이 「reference "ems-gw-live" no longer reports this site」로 거절했다. 사이트는 멀쩡히
- * 있었다 — 코드가 **다른 것을 견주고** 있었다: `origin.source` 는 레퍼런스 등록 이름(그 참조의 사이트
- * 전부에 같다)이고 `master.source` 는 사이트별 인스턴스 id 다. 그래서 사이트가 여럿인 참조에서 온
- * 트윈은 전부 재동기가 불가했고, 오류 문장은 원인을 참조 쪽으로 잘못 가리켰다(내가 그 문장을 읽고
- * 커넥터를 의심했다).
- *
- * 고친 뒤의 규율: ① 가져올 때 사이트 정체를 남긴다 ② 다시 읽기는 그 사이트로 곧장 간다 ③ 기억이 없는
- * 옛 트윈은 마스터의 정체(=인스턴스 id)로 찾는다 ④ 어느 쪽도 못 찾으면 **첫 사이트로 때우지 않는다**.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { pickOriginSite } from '../server/service/reference/reference-master.ts'
-
-const sites = [{ siteId: 'plant-1' }, { siteId: 'plant-2' }, { siteId: 'plant-3' }]
-
-test('기억해 둔 사이트로 곧장 간다', () => {
-  const { site, reason } = pickOriginSite(sites, { siteId: 'plant-2' })
-  assert.equal(site?.siteId, 'plant-2')
-  assert.equal(reason, undefined)
-})
-
-test('기억이 없으면 그렇게 말한다 — 첫 사이트로 때우지 않는다', () => {
-  const { site, reason } = pickOriginSite(sites, {})
-  assert.equal(site, undefined)
-  assert.equal(reason, 'no-remembered-site')
-})
-
-test('기억한 사이트가 사라졌으면 다른 사이트로 덮지 않는다', () => {
-  const { site, reason } = pickOriginSite(sites, { siteId: 'plant-9' })
-  assert.equal(site, undefined)
-  assert.equal(reason, 'site-gone', '다른 현장의 구조를 이 트윈에 덮는 것은 오류 없이 틀린 공장이 된다')
-})
-
-test('빈 문자열은 기억이 아니다', () => {
-  assert.equal(pickOriginSite(sites, { siteId: '  ' }).reason, 'no-remembered-site')
-})
-
-/* 배선이 사라지면 알리지 않고 예전으로 돌아간다 — 소스 모양으로 못 박는다(리졸버는 DB·어댑터를 물고 있다). */
-test('다시 읽기는 인스턴스 정체로 견주고, 가져오기는 사이트 정체를 남긴다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/reference/reference-resolver.ts', import.meta.url)), 'utf-8')
-  /* 옛 비교식은 **설명문에 남아 있어야 한다**(왜 고쳤는지가 사라지면 되돌아간다) — 그래서 코드 줄만 본다. */
-  const code = src
-    .split('\n')
-    .filter(line => !/^\s*(\*|\/\*|\/\/)/.test(line))
-    .join('\n')
-  assert.match(code, /pickOriginSite\(sites, origin\)/, '기억한 사이트로 곧장 가는 길이 있어야 한다')
-  assert.match(code, /master\.source === instanceId/, '옛 트윈은 마스터의 정체로 찾는다(참조 이름이 아니다)')
-  assert.equal(/master\.source === origin\.source/.test(code), false, '참조 이름과 인스턴스 id 를 견주지 않는다')
-  /* 사이트 정체는 남아 있어야 한다 — 현장 기억(spaceId)이 함께 붙어도 그 사실은 변하지 않는다. */
-  assert.match(code, /origin: \{ kind: 'reference', source, siteId: site\.siteId/, '가져올 때 사이트 정체를 남긴다')
-})
-
-/*
- * ── 다시 읽기가 **현장 소속**을 지킨다 (2026-08-18 실측) ─────────────────────
- * 한 현장에 합쳐 둔 EMS 트윈 여덟을 재동기했더니 각자 공간으로 흩어졌다 — 템플릿이 낸 기본 공간으로
- * 돌아갔기 때문이다. 들어온 것이 없다: 오류도 경고도 없고, 트윈은 멀쩡히 돌아간다. 그런데 그 순간 **그 현장의
- * 값(요금·통화)을 함께 잃는다** — 현장 겹은 소속으로 얹히기 때문이다.
- *
- * 원인은 origin 이 「어느 현장에 합쳤나」를 기억하지 않은 것이다(구조만 기억했다).
- */
-test('프로비저닝이 고른 현장을 origin 에 남기고, 다시 읽기가 그것을 따른다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/reference/reference-resolver.ts', import.meta.url)), 'utf-8')
-  const code = src
-    .split('\n')
-    .filter(line => !/^\s*(\*|\/\*|\/\/)/.test(line))
-    .join('\n')
-  assert.match(code, /kind: 'template', templateId, params: effective, \.\.\.\(spaceId \? \{ spaceId \} : \{\}\)/, '템플릿 트윈이 현장을 기억한다')
-  assert.match(code, /const keepSpace = origin\.spaceId \|\| inst\.spaceId/, '기억이 없으면 지금 있는 현장을 지킨다')
-  /* 인자 사이에 재기동 정책이 끼었다(ADR-0029 §2) — 현장을 넘기는 인자는 그대로여야 한다. */
-  assert.match(code, /keepSpace \? \{ spaceId: keepSpace \} : undefined/, '다시 읽기가 그 현장으로 넣는다')
-  assert.match(
-    code,
-    /readRestartPolicy\(inst\.restartPolicy, `resync of twin/,
-    '다시 읽기는 그 트윈의 정책을 그대로 지킨다(구조만 새로 그린다)'
-  )
-})

package/test/retry-plan.test.ts

@@ -1,139 +0,0 @@
-/*
- * ★ **다시 넘길 것인가, 언제인가** — 일꾼의 판단 전부.
- *
- * ── 왜 이 판단이 필요한가 (2026-09-04) ─────────────────────────────────────
- * 승인 직후에 한 번 보내는 것만 있었다. 그래서 **커밋과 발신 사이에 프로세스가 죽으면** 그
- * 조치는 `approved` 로 남고 스스로 나가지 않았다. 그리고 실패한 것을 다시 보내는 것은 사람이
- * 시켜야 했다.
- *
- * ── 실패가 다 같지 않다 (2026-09-02 실측) ──────────────────────────────────
- * 저쪽 인증 정보가 없어 503 이었던 것(고치면 됨)과 `ITEM-1` 이 400 이었던 것(고쳐도 이 조치로는
- * 안 됨)이 같은 모양이었다. 다 다시 하면 없는 자재를 끝없이 두드리고, 다 포기하면 저쪽을 고쳐
- * 놓고도 안 나간다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  AFTER_FIX_PERIOD_MS,
-  AGAIN_BACKOFF_MS,
-  retryDecisionOf
-} from '../server/service/actuation/retry-plan.js'
-
-const NOW = 1_800_000_000_000
-const at = (over: Record<string, unknown> = {}) =>
-  retryDecisionOf({ state: 'failed', dispatchable: true, nowMs: NOW, ...over } as any)
-
-/* ── 첫 시도 — 승인 직후 발신이 놓친 것을 줍는다 ─────────────────────────── */
-
-test('★ 승인됐는데 한 번도 안 나간 것은 바로 집는다 — 그 창이 이 일꾼의 존재 이유다', () => {
-  const d = at({ state: 'approved', attempts: 0 })
-
-  assert.equal(d.take, true)
-  assert.equal(d.attempt, 1)
-})
-
-test('★ 첫 시도는 멱등을 묻지 않는다 — 한 번뿐이라 두 건이 설 수 없다', () => {
-  assert.equal(at({ state: 'approved', attempts: 0, idempotent: false }).take, true)
-})
-
-test('★ 첫 시도는 어댑터의 답을 묻지 않는다 — 아직 아무 답도 하지 않았다', () => {
-  assert.equal(at({ state: 'approved' }).take, true)
-})
-
-/* ── 재시도 — 모르면 넘기지 않는다 ──────────────────────────────────────── */
-
-test('★ 어댑터가 다시 될 일인지 말하지 않았으면 집지 않는다 — 「never」로 접지도 않는다', () => {
-  /*
-   * 모르는 것을 `never` 로 접으면 고칠 수 있는 것을 사람이 포기한다. 그래서 집지 않고 목록에
-   * 「모름」으로 남긴다 — 사람이 보고 정한다.
-   */
-  const d = at({ attempts: 1, idempotent: true })
-
-  assert.equal(d.take, false)
-  assert.equal(d.skip, 'outlook-unknown')
-})
-
-test('★ 멱등을 선언하지 않은 커넥터는 재시도하지 않는다 — 현장에 지시가 두 건 서면 안 된다', () => {
-  const d = at({ attempts: 1, retry: 'again' })
-
-  assert.equal(d.take, false)
-  assert.equal(d.skip, 'not-idempotent')
-})
-
-test('★ 영원히 안 될 것은 집지 않는다 — 사람이 새 조치를 내야 한다', () => {
-  const d = at({ attempts: 1, retry: 'never', idempotent: true })
-
-  assert.equal(d.take, false)
-  assert.equal(d.skip, 'never', '우리 쪽에 고칠 것이 없다는 뜻이다')
-})
-
-/* ── `again` — 짧게 세 번, 그다음 접는다 ────────────────────────────────── */
-
-test('★ 물러서면서 세 번 한다', () => {
-  for (const [i, expected] of AGAIN_BACKOFF_MS.entries()) {
-    const d = at({ attempts: i, retry: 'again', idempotent: true, state: i === 0 ? 'approved' : 'failed' })
-
-    assert.equal(d.take, true, `${i + 1}번째를 안 했다`)
-    assert.equal(d.attempt, i + 1)
-    assert.equal(Date.parse(d.nextAttemptAt!) - NOW, expected, `${i + 1}번째 물러섬이 다르다`)
-  }
-})
-
-test('★ 세 번을 다 쓰면 접는다 — 끝없이 두드리는 것은 소음이다', () => {
-  const d = at({ attempts: AGAIN_BACKOFF_MS.length, retry: 'again', idempotent: true })
-
-  assert.equal(d.take, false)
-  assert.equal(d.skip, 'attempts-spent')
-})
-
-/* ── `after-fix` — 접지 않는다. 이 파일에서 가장 중요한 것 ──────────────── */
-
-test('★ 설정 문제는 횟수로 접지 않는다 — 고쳐 놓고도 손으로 눌러야 하면 안 된다', () => {
-  /*
-   * 2026-09-02 사고가 그 모양이었다: 저쪽이 고쳐진 뒤 사람이 손으로 다시 넘겨서 나갔다.
-   * `after-fix` 는 재시도가 아니라 **기다리는 것**이다.
-   */
-  for (const attempts of [1, 3, 10, 100]) {
-    const d = at({ attempts, retry: 'after-fix', idempotent: true })
-
-    assert.equal(d.take, true, `${attempts}번째에 접었다`)
-    assert.equal(Date.parse(d.nextAttemptAt!) - NOW, AFTER_FIX_PERIOD_MS, '간격이 늘어났다')
-  }
-})
-
-/* ── 물러섬을 표에서 읽는다 ─────────────────────────────────────────────── */
-
-test('★ 아직 이르면 기다린다', () => {
-  const d = at({ attempts: 1, retry: 'again', idempotent: true, nextAttemptAt: new Date(NOW + 10_000).toISOString() })
-
-  assert.equal(d.take, false)
-  assert.equal(d.skip, 'backing-off')
-})
-
-test('★ 때가 되면 집는다', () => {
-  const d = at({ attempts: 1, retry: 'again', idempotent: true, nextAttemptAt: new Date(NOW - 1).toISOString() })
-
-  assert.equal(d.take, true)
-})
-
-test('★ 읽을 수 없는 시각으로 막지 않는다 — 막으면 그 조치가 표에 갇힌다', () => {
-  const d = at({ attempts: 1, retry: 'again', idempotent: true, nextAttemptAt: '언젠가' })
-
-  assert.equal(d.take, true)
-})
-
-/* ── 넘길 수 없는 상태 ──────────────────────────────────────────────────── */
-
-test('★ 종착이면 아무것도 하지 않는다', () => {
-  const d = at({ state: 'acked', dispatchable: false, attempts: 1, retry: 'again', idempotent: true })
-
-  assert.equal(d.take, false)
-  assert.equal(d.skip, 'not-dispatchable')
-})
-
-test('넘길 수 없으면 다른 어떤 값도 그것을 뒤집지 않는다', () => {
-  for (const retry of ['again', 'after-fix', 'never', undefined]) {
-    assert.equal(at({ dispatchable: false, attempts: 0, retry, idempotent: true }).skip, 'not-dispatchable')
-  }
-})