@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/checkpoint-refuses-empty.test.ts

@@ -1,103 +0,0 @@
-/*
- * ★ **아무것도 듣지 못한 것을 「비었다」로 적지 않는다** — 체크포인트가 좋은 스냅샷을 덮지 않게.
- *
- * ── 무엇이 손실을 영구화하고 있었나 (2026-08-24 실측) ────────────────────────
- * 미러가 재기동하면 관측 축(재고·오더·작업)을 들고 오지 않는다(`startLive` 가 되찾은 상태를 버린다 —
- * 「다음 계측이 정정한다」는 전제). 그런데 원본이 **커서 증분**으로 말하는 현장에서는 그 정정이 오지
- * 않는다: 커서가 따라잡힌 뒤 원본이 변하지 않으면 미러는 영구히 빈 채다.
- *
- * 실측(포천, `operato-chef-v1-pocheon`):
- *
- *   저널을 계산하면        items 741 · orders 2,856 · tasks 9,250 · nowTime 2026-04-15
- *   라이브 미러          items   0 · orders     0 · tasks     0 · nowTime 2026-01-01
- *   저장된 스냅샷        rev 221,884 · items 741 · orders 2,780 · tasks 6,353  (어제 것)
- *   그런데 이 버전이       같은 키에 **빈 상태**를 쓰고 있었다
- *
- * 그러면 되살릴 캐시가 사라진다. 재기동이 상태를 버리는 것은 저널에서 되살릴 수 있지만, **캐시를
- * 지우는 것은 그 복구 수단을 함께 지운다.**
- *
- * ── 왜 리비전으로는 막을 수 없나 ────────────────────────────────────────────
- * 저널 줄 번호는 **관측이 없어도 자란다**(다른 축·다른 트윈의 사건, 체크포인트 자체). 그래서
- * 「리비전이 더 크면 진전」이라는 규칙은 빈 상태를 통과시킨다.
- *
- * 막는 기준은 **「들은 것이 있나」**다. 유입이 한 건도 없었다면 그 빈 상태는 원본이 「비었다」고
- * 말한 것이 아니라 **우리가 아무것도 못 들은 것**이다 — 그 둘을 같은 값으로 적으면 「모름」이
- * 「없음」이 된다. 이 저장소가 여러 번 거절한 모양이다.
- *
- * 원본이 실제로 「다 비었다」고 말한 경우는 막지 않는다 — 그때는 유입이 있었으므로 이 문을 지난다.
- *
- * ── 엔진 본체는 부를 수 없다 ────────────────────────────────────────────────
- * DB 를 물고 있어 시험에서 부르지 못한다(§`snapshot-freshness` 와 같은 사정). 그래서 판정식만 떼어
- * 시험하고, **그 식이 엔진에 실제로 있는지**를 소스로 함께 확인한다 — 식만 시험하면 엔진이 그것을
- * 쓰지 않아도 초록이다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-/** 엔진의 조건과 같은 식(`twin-engine.persistSnapshot`). */
-const observed = (s: any): number => (s?.items?.length ?? 0) + (s?.orders?.length ?? 0) + (s?.tasks?.length ?? 0)
-
-const refuses = (live: any, stored: any, ingestedTotal: number): boolean =>
-  !(ingestedTotal > 0) && observed(live) === 0 && observed(stored) > 0
-
-const RICH = { items: [{ epc: 'a' }], orders: [{ id: 'o' }], tasks: [{ id: 't' }] }
-const EMPTY = { items: [], orders: [], tasks: [] }
-
-test('못 들었고 라이브가 비었는데 저장된 것에 사실이 있으면 — **거절한다**', () => {
-  /* ★ 이 시험이 막는 것. 통과시키면 되살릴 유일한 사본이 사라진다. */
-  assert.equal(refuses(EMPTY, RICH, 0), true)
-})
-
-test('들은 것이 있으면 통과한다 — 원본이 「다 비었다」고 말한 것은 사실이다', () => {
-  /*
-   * 창고가 실제로 비는 것은 정상이다. 그때는 유입이 있었으므로 그 빈 상태가 **관측**이고,
-   * 여기서 막으면 스냅샷이 영구히 낡는다(고치려던 것의 반대 방향으로 틀린다).
-   */
-  assert.equal(refuses(EMPTY, RICH, 1), false)
-  assert.equal(refuses(EMPTY, RICH, 24839), false)
-})
-
-test('라이브에 사실이 있으면 통과한다 — 못 들었어도 심어진 상태는 지킬 값이다', () => {
-  assert.equal(refuses(RICH, RICH, 0), false)
-})
-
-test('저장된 것이 비어 있으면 막을 것이 없다 — 첫 체크포인트를 가로막지 않는다', () => {
-  /* 처음 뜬 트윈은 저장된 것이 없다. 여기서 막으면 그 트윈은 영원히 스냅샷을 갖지 못한다. */
-  assert.equal(refuses(EMPTY, EMPTY, 0), false)
-  assert.equal(refuses(EMPTY, null, 0), false)
-  assert.equal(refuses(EMPTY, undefined, 0), false)
-})
-
-test('축 하나만 남아도 사실이다 — 셋을 합쳐 센다', () => {
-  /*
-   * 오더만 남고 재고가 빈 상태는 흔하다(다 내보낸 창고). 축마다 따로 판정하면 그 상태가
-   * 「비었다」로 읽힌다.
-   */
-  assert.equal(refuses(EMPTY, { items: [], orders: [{ id: 'o' }], tasks: [] }, 0), true)
-  assert.equal(refuses(EMPTY, { items: [], orders: [], tasks: [{ id: 't' }] }, 0), true)
-})
-
-test('리비전은 판정에 쓰지 않는다 — 저널 번호는 관측이 없어도 자란다', () => {
-  /*
-   * ★ 이 단정이 **틀린 기준으로 돌아가는 것**을 막는다. 실측에서 저장된 스냅샷의 리비전은 221,884
-   * 였고 라이브는 그보다 큰 번호를 들고 있었다 — 리비전을 기준으로 삼으면 빈 상태가 통과한다.
-   */
-  const live = { ...EMPTY, revision: 999999 }
-  const stored = { ...RICH, revision: 1 }
-  assert.equal(refuses(live, stored, 0), true, '번호가 커도 사실이 없으면 덮지 않는다')
-})
-
-test('엔진이 실제로 이 판정을 한다 — 식만 시험하면 엔진이 안 써도 초록이다', () => {
-  const src = readFileSync(join(import.meta.dirname, '..', 'server', 'engine', 'twin-engine.ts'), 'utf8')
-  /* 주석을 걷어낸 코드만 — 「덮지 않는다」를 적어 둔 근거가 가드를 뒤집지 않게. */
-  const code = src.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/(^|[^:])\/\/.*$/gm, '$1')
-  const at = code.indexOf('persistSnapshot')
-  assert.ok(at > 0, 'persistSnapshot 이 있어야 한다')
-  const body = code.slice(at, at + 2000)
-  assert.match(body, /ingestedTotal/, '「들은 것이 있나」를 본다')
-  assert.match(body, /items\?\.length[\s\S]{0,80}orders\?\.length[\s\S]{0,80}tasks\?\.length/, '관측 축 셋을 합쳐 센다')
-  assert.match(body, /checkpoint refused/, '거절을 말한다 — 알리지 않고 거절하지 않는다')
-  assert.doesNotMatch(body.slice(0, body.indexOf('checkpoint refused')), /revision >|revision </, '리비전 비교로 판정하지 않는다')
-})

package/test/choose-recipe.test.ts

@@ -1,117 +0,0 @@
-/*
- * ★ **어느 레시피로 만들었나 — 짐작하지 않는다.**
- *
- * ── 무엇이 있었나 (2026-09-05) ─────────────────────────────────────────────
- * 계보 진단이 자재로 되짚어 `recipes.find(...)` 로 **먼저 걸리는 하나**를 골랐다. 배열 순서가 답을
- * 정한다는 뜻이다. 그리고 한 자재에 레시피가 둘인 경우가 이미 있다 — plant 마스터 실측:
- *
- *   BOLT-M8  →  RCP-BOLT-STD    유효시작 2026-09-01 09:25:29.447
- *               RCP-BOLT-FAST   유효시작 2026-09-01 09:25:29.510
- *
- * 빠른 방식으로 만든 볼트인데 표준 방식과 견주고 「설계와 다릅니다」가 나온다. 사람은 라인에
- * 문제가 있다고 믿고 확인하러 간다. **틀린 답이 확신에 찬 얼굴로 나오는 것**이 그 상태였다.
- *
- * ── 답은 적혀 있었다 ───────────────────────────────────────────────────────
- * 만들 때 정해지는 사실이고 커널이 오더에 싣는다(`FlowOrder.recipeKey`). 변환 사건은 그 오더를
- * 거래 식별자로 가리키고, 계보 함수는 그 값을 이미 꺼내 놓고도 쓰지 않았다.
- *
- * 세 자리가 다 있었고 **마지막 연결만 없었다.**
- *
- * ── 왜 순수 함수인가 ───────────────────────────────────────────────────────
- * 규칙만 따로 재려면 DB 도 트윈도 필요 없어야 한다. 여기서 값으로 못 박아 두면 다음에 「하나쯤
- * 골라 주는 게 친절하지 않나」가 올라올 때 그 줄이 빨개진다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { chooseRecipe } from '../server/service/twin-model/choose-recipe.js'
-
-const STD = { key: 'RCP-BOLT-STD', outputs: [{ material: 'BOLT-M8' }] }
-const FAST = { key: 'RCP-BOLT-FAST', outputs: [{ material: 'BOLT-M8' }] }
-const OTHER = { key: 'RCP-CT-BLANK', outputs: [{ material: 'CT-BLANK' }] }
-
-const ALL = [STD, FAST, OTHER]
-
-/* ── 오더가 말하면 그것을 쓴다 ───────────────────────────────────────────── */
-
-test('★ 오더가 말한 레시피를 쓴다 — 버전이 둘이어도 고민하지 않는다', () => {
-  const r = chooseRecipe(ALL, [STD, FAST], 'RCP-BOLT-FAST')
-
-  assert.equal(r.recipe, FAST, '오더가 말했는데 다른 것을 골랐다')
-  assert.equal(r.basis, 'order')
-})
-
-test('★ 배열 순서가 답을 바꾸지 않는다 — 옛 결함의 핵심이 이것이었다', () => {
-  const forward = chooseRecipe([STD, FAST], [STD, FAST], 'RCP-BOLT-FAST')
-  const reversed = chooseRecipe([FAST, STD], [FAST, STD], 'RCP-BOLT-FAST')
-
-  assert.equal(forward.recipe, reversed.recipe, '순서를 뒤집으니 답이 달라졌다')
-  assert.equal(forward.recipe?.key, 'RCP-BOLT-FAST')
-})
-
-/* ── 오더가 말 안 할 때 ─────────────────────────────────────────────────── */
-
-test('★ 후보가 하나면 쓴다 — 고를 것이 없으면 짐작이 아니다', () => {
-  const r = chooseRecipe(ALL, [OTHER], undefined)
-
-  assert.equal(r.recipe, OTHER)
-  assert.equal(r.basis, 'only-candidate')
-})
-
-test('★ 후보가 둘 이상이면 답하지 않는다 — 여기가 옛 결함의 자리다', () => {
-  /*
-   * 옛 코드: `recipes.find(...)` — 이 자리에서 STD 를 돌려줬다. 그 답이 틀릴 확률이 절반이고,
-   * 틀렸다는 사실은 아무 데도 안 남았다.
-   */
-  const r = chooseRecipe(ALL, [STD, FAST], undefined)
-
-  assert.equal(r.recipe, undefined, '어느 것으로 만들었는지 모르는 채로 하나를 골랐다')
-  assert.equal(r.basis, 'ambiguous')
-})
-
-/* ── 어긋남과 모름을 가른다 ─────────────────────────────────────────────── */
-
-test('★ 오더가 말한 레시피가 선언에 없으면 「모른다」가 아니라 「어긋났다」', () => {
-  /*
-   * 사람이 할 일이 다르다. 어긋남은 선언이나 원본을 고칠 일이고, 모호함은 그 개체의 기록이 없는
-   * 일이다. 한 낱말로 합치면 화면이 둘 중 어느 쪽인지 말할 수 없다.
-   */
-  const r = chooseRecipe(ALL, [STD, FAST], 'RCP-사라진것')
-
-  assert.equal(r.recipe, undefined)
-  assert.equal(r.basis, 'said-but-undeclared')
-})
-
-test('★ 후보가 아예 없으면 none — 「이 자재를 내는 레시피가 없다」', () => {
-  const r = chooseRecipe(ALL, [], undefined)
-
-  assert.equal(r.recipe, undefined)
-  assert.equal(r.basis, 'none')
-})
-
-/* ── 무너지지 않는다 ────────────────────────────────────────────────────── */
-
-test('빈 목록·빈 값에도 터지지 않는다', () => {
-  assert.equal(chooseRecipe([], [], undefined).basis, 'none')
-  assert.equal(chooseRecipe([], [], 'X').basis, 'said-but-undeclared')
-  assert.equal(chooseRecipe(ALL, [STD], '').basis, 'only-candidate', '빈 문자열은 「말했다」가 아니다')
-})
-
-/* ── 검사가 실제로 무언가를 재나 ─────────────────────────────────────────── */
-
-test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  /* 네 판정이 다 나오는지. 하나라도 안 나오면 위 검사들이 같은 가지만 밟고 있는 것이다. */
-  const bases = new Set([
-    chooseRecipe(ALL, [STD, FAST], 'RCP-BOLT-FAST').basis,
-    chooseRecipe(ALL, [OTHER], undefined).basis,
-    chooseRecipe(ALL, [STD, FAST], undefined).basis,
-    chooseRecipe(ALL, [STD], 'RCP-없음').basis,
-    chooseRecipe(ALL, [], undefined).basis
-  ])
-
-  assert.deepEqual(
-    [...bases].sort(),
-    ['ambiguous', 'none', 'only-candidate', 'order', 'said-but-undeclared'],
-    `판정이 다 나오지 않는다: ${[...bases].join(' · ')}`
-  )
-})

package/test/column-type-portability.test.ts

@@ -1,122 +0,0 @@
-/*
- * 컬럼 타입은 **드라이버 방언을 적지 않는다.**
- *
- * ── 무엇이 났나 (2026-08-19) ────────────────────────────────────────────────
- * 릴리즈 부팅이 Postgres 에서 막혔다:
- *
- *   DataTypeNotSupportedError: Data type "datetime" in "TwinEvent.eventTime" is not supported by "postgres"
- *
- * `datetime` 은 **MySQL·MSSQL 의 이름**이다(Postgres·Oracle 은 거절한다). 거꾸로 `timestamp` 는 MySQL
- * 이 받지만 예전 주석은 「sqlite 가 지원하지 않는다」고 적어 두었다 — sqlite 드라이버는 타입 목록이
- * 비어 있어 **아무 이름도 검증하지 않는다**(그래서 개발 중에는 무엇을 적어도 통과했다). 결국 다섯
- * 드라이버에 다 통하는 날짜 이름은 **없다.**
- *
- * 그래서 이름을 고르는 일을 TypeORM 에 맡긴다: `emitDecoratorMetadata` 가 켜져 있으므로 `Date` 속성에
- * `@Column()` 만 달면 드라이버별로 알맞게 바뀐다(Postgres `timestamp without time zone` · sqlite·MySQL
- * `datetime` · Oracle `timestamp`) — sqlite 거동은 그대로다.
- *
- * 이 시험은 그 규율을 **소스에서** 지킨다: 이 패키지의 엔티티가 명시한 타입 이름은 네 드라이버(검증을
- * 하는 쪽) 모두가 아는 것이어야 한다. 개발 DB 가 sqlite 라 아무것도 못 잡아 주기 때문에 필요하다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { createRequire } from 'node:module'
-import { join } from 'node:path'
-
-const req = createRequire(import.meta.url)
-
-/** 드라이버가 아는 타입 이름 — **TypeORM 소스에서 읽는다**(우리가 목록을 옮겨 적지 않는다). */
-function supportedTypes(driverPath: string): Set<string> {
-  const src = readFileSync(req.resolve(driverPath), 'utf-8')
-  const m = src.match(/supportedDataTypes = \[([\s\S]*?)\];/)
-  assert.ok(m, `${driverPath}: supportedDataTypes 를 찾지 못했다(TypeORM 구조가 바뀌었다)`)
-  return new Set((m![1].match(/"[^"]+"/g) ?? []).map(s => s.slice(1, -1)))
-}
-
-/*
- * sqlite 는 목록이 비어 있다 = **검증하지 않는다.** 그래서 여기 넣지 않는다 — 넣으면 모든 타입이
- * 「sqlite 가 모른다」로 걸려 이 시험이 소음이 된다. 개발 DB 가 아무것도 못 잡는다는 사실이 이 시험의 이유다.
- */
-const DRIVERS: Record<string, string> = {
-  postgres: 'typeorm/driver/postgres/PostgresDriver.js',
-  mysql: 'typeorm/driver/mysql/MysqlDriver.js',
-  oracle: 'typeorm/driver/oracle/OracleDriver.js',
-  mssql: 'typeorm/driver/sqlserver/SqlServerDriver.js'
-}
-
-function entitySources(): { file: string; src: string }[] {
-  const root = fileURLToPath(new URL('../server', import.meta.url))
-  const out: { file: string; src: string }[] = []
-  const walk = (dir: string) => {
-    for (const name of readdirSync(dir)) {
-      const path = join(dir, name)
-      if (statSync(path).isDirectory()) { walk(path); continue }
-      if (!name.endsWith('.ts')) continue
-      const src = readFileSync(path, 'utf-8')
-      if (/@Entity\(/.test(src)) out.push({ file: path.slice(root.length + 1), src })
-    }
-  }
-  walk(root)
-  return out
-}
-
-test('엔티티가 있다 — 훑을 대상이 없으면 이 시험은 아무것도 지키지 않는다', () => {
-  assert.ok(entitySources().length >= 5, '이 패키지의 엔티티를 찾아야 한다')
-})
-
-/*
- * **드라이버마다 이름이 다른 컬럼은 코드가 고른다.**
- *
- * 긴 글이 그렇다: `text` 를 Oracle 이 모르고(그쪽은 `clob`), MySQL 계열은 `longtext`, MSSQL 은
- * `nvarchar(MAX)` 를 쓴다. 이 레포의 정본 관행은 `DATABASE_TYPE` 으로 분기하는 것이다
- * (`board-service` 의 `Board.model`) — 그 분기는 이 시험의 리터럴 검사에 걸리지 않는다(정상이다).
- *
- * 그래서 면제 목록을 두지 않는다: 고정 리터럴은 전부 잡고, 갈라야 하는 컬럼은 관행대로 가른다.
- */
-const KNOWN_GAPS = new Set<string>()
-
-test('명시한 컬럼 타입은 네 드라이버가 모두 아는 이름이다 — 개발 DB(sqlite)는 아무것도 잡아 주지 않는다', () => {
-  const supported = Object.fromEntries(Object.entries(DRIVERS).map(([n, p]) => [n, supportedTypes(p)]))
-  const violations: string[] = []
-  for (const { file, src } of entitySources()) {
-    for (const m of src.matchAll(/type:\s*'([a-z][a-z0-9 _]*)'/g)) {
-      const type = m[1]
-      const missing = Object.entries(supported).filter(([, s]) => !s.has(type)).map(([n]) => n)
-      if (!missing.length) continue
-      const line = `${file}: type '${type}' — ${missing.join(', ')} 가 모른다`
-      if (!KNOWN_GAPS.has(line)) violations.push(line)
-    }
-  }
-  assert.deepEqual(violations, [], `드라이버 방언을 적은 컬럼:\n${violations.join('\n')}`)
-})
-
-test('면제를 남겨 두면 그것이 아직 사실인지 확인한다 — 유령 면제를 남기지 않는다', () => {
-  const supported = Object.fromEntries(Object.entries(DRIVERS).map(([n, p]) => [n, supportedTypes(p)]))
-  const present = new Set<string>()
-  for (const { file, src } of entitySources()) {
-    for (const m of src.matchAll(/type:\s*'([a-z][a-z0-9 _]*)'/g)) {
-      const missing = Object.entries(supported).filter(([, s]) => !s.has(m[1])).map(([n]) => n)
-      if (missing.length) present.add(`${file}: type '${m[1]}' — ${missing.join(', ')} 가 모른다`)
-    }
-  }
-  for (const gap of KNOWN_GAPS) assert.ok(present.has(gap), `이 예외는 이제 사실이 아니다(목록에서 지워라): ${gap}`)
-})
-
-test('날짜 컬럼은 이름을 적지 않는다 — TypeORM 이 드라이버별로 고르게 둔다', () => {
-  for (const { file, src } of entitySources()) {
-    assert.equal(/type:\s*'(datetime|timestamp|timestamptz|datetime2|smalldatetime)'/.test(src), false, `${file}: 날짜 타입 이름을 적었다`)
-  }
-})
-
-/*
- * 드라이버별로 갈라야 하는 컬럼은 **갈린 상태로** 있어야 한다 — 다시 고정 리터럴로 돌아가면 그 드라이버가
- * 부팅에서 거절한다(감사 사유는 사람이 쓰는 글이라 길이를 자르지 않는다).
- */
-test('긴 글 컬럼은 DATABASE_TYPE 으로 갈린다 — 관행을 되돌리지 않는다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/twin-audit/twin-audit-event.ts', import.meta.url)), 'utf-8')
-  assert.match(src, /const DATABASE_TYPE = config\.get\('ormconfig', \{\}\)\.type/, '관행과 같은 자리에서 읽는다')
-  for (const name of ['longtext', 'clob', 'nvarchar', 'text']) assert.ok(src.includes(`'${name}'`), `${name} 갈래가 있어야 한다`)
-  assert.match(src, /length: DATABASE_TYPE == 'mssql' \? 'MAX' : undefined/, 'MSSQL 은 길이까지 말해야 잘리지 않는다')
-})

package/test/command-routing.test.ts

@@ -1,61 +0,0 @@
-/*
- * ★ 커맨드 라우팅 판정 — 권위(모드) × 성격(주석/액추에이션).
- *
- * ── 무엇이 문제였나 ─────────────────────────────────────────────────────────
- * 리졸버가 `inst.runtime.dispatch(...)` 를 곧바로 불렀다. 그런데 `runtime` 은 **시뮬 경로에서만**
- * 만들어진다. 실물을 비추는 트윈(mirror)에서는 그 한 줄이 `TypeError` 로 터져 조치 채널이 통째로
- * 닿지 않았다 — 사용자에게는 이유 있는 거절이 아니라 그냥 실패였다.
- *
- * ── 그냥 열면 안 되는 이유 ──────────────────────────────────────────────────
- * 미러에서 액추에이션을 허용하면 **새 거짓말이 생긴다**: 트윈은 "보류됨" 이라 말하고 실 시스템은
- * 모른다. 그래서 실 프로세스를 바꾸는 커맨드는 아웃바운드 어댑터가 붙기 전까지 이유를 밝혀 거절한다
- * (`design/plans/command-routing.md` P0). 확인(ack)은 트윈 쪽 주석이라 미러에서도 통과한다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { routeCommand, isActuation } from '../server/engine/command-routing.ts'
-
-const sim = { hasRuntime: true, hasKernelDispatch: true }
-const mirror = { mode: 'live', hasRuntime: false, hasKernelDispatch: true }
-
-test('시뮬 — 커맨드는 커널 런타임으로 간다(현행 경로 그대로)', () => {
-  assert.deepEqual(routeCommand(sim, true, 'order.hold'), { target: 'runtime' })
-  assert.deepEqual(routeCommand(sim, true, 'attention.ack'), { target: 'runtime' })
-})
-
-test('미러 — 확인(ack)은 관측 커널로 간다. 현실을 건드리지 않는 주석이다', () => {
-  assert.deepEqual(routeCommand(mirror, true, 'attention.ack'), { target: 'kernel' })
-})
-
-test('미러 — 실 프로세스를 바꾸는 커맨드는 이유를 밝히고 거절한다', () => {
-  for (const type of ['order.hold', 'order.resume', 'order.release', 'resource.down', 'resource.repair', 'resource.add']) {
-    const r = routeCommand(mirror, true, type)
-    assert.equal(r.target, 'reject', `${type} 은 미러에서 통과하면 안 된다`)
-    if (r.target !== 'reject') return
-    assert.equal(r.errorCode, 'actuation-not-wired')
-    assert.equal(r.errorParams?.type, type, '어느 커맨드였는지 함께 알려야 한다')
-  }
-})
-
-test('없는 인스턴스와 다른 도메인은 같은 사유로 거절한다 — 있음/없음이 구별되면 그것이 정보다', () => {
-  assert.deepEqual(routeCommand(undefined, false, 'attention.ack'), { target: 'reject', errorCode: 'no-instance' })
-  assert.deepEqual(routeCommand(sim, false, 'attention.ack'), { target: 'reject', errorCode: 'no-instance' })
-})
-
-test('런타임이 없는 시뮬 — 오류를 내지 않고 이유를 알린다', () => {
-  assert.deepEqual(routeCommand({ hasRuntime: false, hasKernelDispatch: true }, true, 'order.hold'), { target: 'reject', errorCode: 'no-runtime' })
-})
-
-test('커널이 커맨드를 못 받는 미러 — 확인도 이유를 말하고 멈춘다', () => {
-  assert.deepEqual(routeCommand({ mode: 'live', hasRuntime: false, hasKernelDispatch: false }, true, 'attention.ack'), { target: 'reject', errorCode: 'no-runtime' })
-})
-
-test('빈 커맨드 종류는 거절한다 — 무엇을 하라는지 모르는 것을 보내지 않는다', () => {
-  assert.deepEqual(routeCommand(sim, true, ''), { target: 'reject', errorCode: 'unknown-command' })
-})
-
-test('성격 판정 — 확인만 주석이고 나머지는 액추에이션이다', () => {
-  assert.equal(isActuation('attention.ack'), false)
-  for (const t of ['order.hold', 'resource.add', 'order.release']) assert.equal(isActuation(t), true, t)
-})

package/test/command-store-writes-columns.test.ts

@@ -1,126 +0,0 @@
-/*
- * ★ **칸이 있으면 쓰는 길도 있어야 한다** — `save` 가 손으로 든 목록이라 새 칸을 빠뜨린다.
- *
- * ── 무엇이 있었나 (2026-09-04) ──────────────────────────────────────────────
- * 일꾼에 네 칸을 더했다 — `dispatch_note_next` · `retry` · `attempts` · `next_attempt_at`.
- * 엔티티에 선언하고 마이그레이션까지 걸었는데 **`save` 가 그 칸을 안 썼다.** 그 함수는 쓸 칸을
- * 손으로 들고 있고, 새 칸이 그 목록에 없었다.
- *
- * 그래서 일꾼이 물러섬을 계산해 넘겼는데 표에는 아무것도 안 남았다. 재기동하면 물러서던 것이
- * 전부 즉시 재시도가 되고, 목록의 「몇 번 해 봤나」가 영원히 비어 있다. **오류는 나지 않는다.**
- *
- * 30분을 뒤진 끝에 찾았고, 이 저장소에서 하루 종일 「자리는 있고 길이 없다」로 부른 것과 같다 —
- * 이번에는 **칸과 쓰는 길** 사이였다.
- *
- * ── 무엇을 검사하나 ────────────────────────────────────────────────────────
- * 엔티티가 칸을 가진 필드는 `save` 가 쓰거나, 안 쓰는 이유가 아래 표에 있어야 한다. 목록을
- * 소스에서 읽는다 — 손으로 적으면 새 칸이 조용히 빠지고 그것이 바로 이 검사가 막으려는 실패다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-const bare = (p: string): string =>
-  readFileSync(new URL(p, import.meta.url), 'utf8')
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .replace(/\/\/[^\n]*/g, '')
-
-const ENTITY = bare('../server/service/actuation/twin-command.ts')
-const STORE = bare('../server/service/actuation/command-store.ts')
-
-/**
- * `save` 가 일부러 안 쓰는 칸 — 이유와 함께.
- *
- * 비어 있는 것이 정상이 아니다: 이 표는 「고치는 경로가 다른 칸」을 든다. 채울 때 그 이유가
- * 「다른 함수가 쓴다」인지 「읽기 전용」인지 적어야 한다.
- */
-const NOT_BY_SAVE: { column: string; why: string }[] = [
-  { column: 'domain', why: '열쇠 — 테넌트로 좁히는 조건이다' },
-  { column: 'instanceId', why: '낼 때 정해지고 바뀌지 않는다(create)' },
-  { column: 'type', why: '낼 때 정해지고 바뀌지 않는다(create)' },
-  { column: 'payload', why: '낼 때 정해지고 바뀌지 않는다 — 지시 내용은 제안될 때 굳는다' },
-  { column: 'origin', why: '낼 때 정해지고 바뀌지 않는다(create)' },
-  { column: 'proposedBy', why: '낼 때 정해지고 바뀌지 않는다(create)' },
-  { column: 'reversible', why: '명세에서 온다 — 낼 때 굳는다(create)' },
-  { column: 'causeRef', why: '낼 때 정해진다 — 규칙이 낸 근거(create)' },
-  { column: 'ruleRef', why: '낼 때 정해진다(create)' },
-  { column: 'effectStatus', why: '유입 경로가 `recordEffects` 로만 적는다 — 관측이 조치의 수명에 손대지 않게' },
-  { column: 'effectAt', why: '같음 — `recordEffects`' },
-  { column: 'effectSeen', why: '같음 — `recordEffects`' },
-  { column: 'createdAt', why: 'TypeORM 이 넣는다' },
-  { column: 'updatedAt', why: 'TypeORM 이 넣는다' }
-]
-
-/** 엔티티가 컬럼을 선언한 속성 이름들 — 데코레이터 다음 줄의 필드를 읽는다. */
-function entityColumns(): string[] {
-  const out: string[] = []
-  const lines = ENTITY.split('\n')
-  for (let i = 0; i < lines.length; i++) {
-    if (!/@(Column|CreateDateColumn|UpdateDateColumn|ManyToOne)\(/.test(lines[i])) continue
-    /* 데코레이터가 여럿 붙는다(@Column + @Field) — 다음 필드 줄까지 내려간다. */
-    for (let j = i + 1; j < Math.min(i + 6, lines.length); j++) {
-      const m = lines[j].match(/^\s{2}([a-zA-Z][\w]*)\??:/)
-      if (m) {
-        out.push(m[1])
-        break
-      }
-    }
-  }
-  return [...new Set(out)]
-}
-
-/** `save` 가 실제로 쓰는 속성 — 그 함수 본문에서만 읽는다. */
-function savedColumns(): string[] {
-  const start = STORE.indexOf('save: async')
-  assert.ok(start > 0, '`save` 를 못 찾았다 — 이 검사가 따라가야 한다')
-  const body = STORE.slice(start, STORE.indexOf('create: async', start))
-  return [...new Set([...body.matchAll(/^\s{10}([a-zA-Z][\w]*):/gm)].map(m => m[1]))]
-}
-
-test('★ 엔티티가 든 칸은 save 가 쓰거나 안 쓰는 이유가 적혀 있다', () => {
-  const excused = new Set(NOT_BY_SAVE.map(e => e.column))
-  const written = new Set(savedColumns())
-
-  const orphans = entityColumns().filter(c => !written.has(c) && !excused.has(c))
-
-  assert.deepEqual(
-    orphans,
-    [],
-    '엔티티에 칸이 있는데 `save` 가 안 쓴다. 값이 계산되고 표에는 안 남는다 — 오류는 나지 않는다:\n  ' +
-      orphans.join('\n  ') +
-      '\n쓰게 하거나, 다른 경로로 쓴다면 NOT_BY_SAVE 에 이유를 적는다.'
-  )
-})
-
-test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  /*
-   * 정규식이 엔티티 모양을 못 따라가면 목록이 비고, 그러면 위 검사가 **초록인데 아무것도 안 재는
-   * 상태**가 된다. 오늘 이 저장소의 다른 검사가 그렇게 났다.
-   */
-  const columns = entityColumns()
-  const written = savedColumns()
-
-  assert.ok(columns.length > 15, `엔티티 칸을 ${columns.length}개만 읽었다 — 정규식이 모양을 놓쳤다`)
-  assert.ok(written.length > 5, `save 가 쓰는 칸을 ${written.length}개만 읽었다`)
-
-  /* 예외 표가 낡지 않았나 — 지워진 칸이 남아 있으면 검사를 넓혀 주는 척만 한다. */
-  const known = new Set(columns)
-  const stale = NOT_BY_SAVE.map(e => e.column).filter(c => !known.has(c))
-  assert.deepEqual(stale, [], `예외 표에 있는데 엔티티에 없다:\n  ${stale.join('\n  ')}`)
-
-  /* 이유 없는 예외는 예외가 아니다. */
-  const mute = NOT_BY_SAVE.filter(e => !e.why?.trim()).map(e => e.column)
-  assert.deepEqual(mute, [], `이유 없이 예외로 올렸다:\n  ${mute.join('\n  ')}`)
-})
-
-test('★ 일꾼이 쓰는 네 칸이 실제로 save 를 지난다', () => {
-  /*
-   * 위 검사는 목록 대조라 예외 표에 올리면 통과한다. 이 넷은 **물러섬이 표에 남는 근거**여서
-   * 예외가 될 수 없다 — 이름으로 못 박는다.
-   */
-  const written = new Set(savedColumns())
-
-  for (const c of ['dispatchNoteNext', 'retry', 'attempts', 'nextAttemptAt']) {
-    assert.ok(written.has(c), `save 가 ${c} 를 안 쓴다 — 물러섬이 재기동에 사라진다`)
-  }
-})

package/test/connection-portability-doors.test.ts

@@ -1,87 +0,0 @@
-/*
- * ★ **연결 이관의 문 셋** — 몸통은 순수 함수이고, 이 검사는 **문이 그 규율을 지키는지** 본다.
- *
- * ── 무엇을 옮기나 (사용자와 맞춘 개념, 2026-09-05) ────────────────────────
- * 옮기는 것은 「붙는 법」이지 「붙은 결과」가 아니다. 마스터·사실·잰 값·비밀값은 안 옮긴다 —
- * 앞의 셋은 다시 얻을 수 있고, 비밀값은 그 환경의 것이지 셋업이 아니다.
- *
- * ── 이 검사가 지키는 것 ────────────────────────────────────────────────────
- * 문이 몸통의 판단을 **뒤집지 않는지**다. 몸통 시험 19개가 이미 「비밀값이 안 나간다」를 지키는데,
- * 문이 그것을 되살려 쓰면 그 19개가 아무것도 못 막는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { exportConnections, planImport, SECRET_KEYS } from '../server/service/reference/connection-portability.js'
-
-const row = (over: any = {}) => ({
-  source: 'mes-miratek',
-  system: 'operato-plant',
-  siteName: '미라텍',
-  adapterType: 'operato-plant',
-  connectionConfig: { baseUrl: 'https://plant.example', siteId: 'mes-miratek', token: 'SECRET-VALUE', hookSecret: 'ALSO-SECRET' },
-  ...over
-})
-
-test('★ 비밀값이 패키지에 안 나간다 — 이름만 나간다', () => {
-  const b = exportConnections([row()], { at: '2026-09-05T00:00:00.000Z' })
-  const text = JSON.stringify(b)
-
-  assert.ok(!text.includes('SECRET-VALUE'), '토큰이 패키지에 실렸다')
-  assert.ok(!text.includes('ALSO-SECRET'), '훅 비밀값이 패키지에 실렸다')
-  assert.deepEqual(b.connections[0].secretsRequired.sort(), ['hookSecret', 'token'], '무엇을 채워야 하는지 말하지 않는다')
-})
-
-test('★ 선언은 나간다 — 그것이 옮기려는 것이다', () => {
-  const b = exportConnections([row()], { at: '2026-09-05T00:00:00.000Z' })
-  const c = b.connections[0]
-
-  assert.equal(c.adapterType, 'operato-plant')
-  assert.equal(c.config.baseUrl, 'https://plant.example')
-  assert.equal(c.config.siteId, 'mes-miratek')
-})
-
-test('★ 새 비밀 칸도 기본으로 안 나간다 — 이름 규칙으로 거른다', () => {
-  /*
-   * 비밀 칸이 하나 늘 때 이 목록을 안 고치면 그 값이 파일로 나간다. 그래서 규칙이 이름이고,
-   * 그 규칙이 지금 무엇을 아는지 값으로 못 박는다.
-   */
-  assert.ok(SECRET_KEYS.includes('token' as any))
-  assert.ok(SECRET_KEYS.includes('hookSecret' as any))
-  assert.ok(SECRET_KEYS.includes('intakeSecret' as any))
-  assert.ok(SECRET_KEYS.length >= 4, `비밀 칸 이름을 ${SECRET_KEYS.length}개만 안다`)
-})
-
-test('★ 없는 비밀값을 지어내지 않는다 — 이름을 대고 사람에게 넘긴다', () => {
-  const b = exportConnections([row()], { at: '2026-09-05T00:00:00.000Z' })
-  /* 이 환경에는 그 비밀값이 없다. */
-  const plan = planImport(b, [], () => false)
-
-  const needs = plan.needsHuman.find(n => n.source === 'mes-miratek')
-  assert.ok(needs, '사람이 채울 것을 말하지 않는다')
-  assert.deepEqual(needs!.keys.sort(), ['hookSecret', 'token'])
-})
-
-test('★ 이미 있는 연결의 비밀값을 패키지가 안 지운다', () => {
-  const b = exportConnections([row()], { at: '2026-09-05T00:00:00.000Z' })
-  const existing = [{ source: 'mes-miratek', connectionConfig: { token: 'LIVE-TOKEN' } }]
-  const plan = planImport(b, existing, () => false)
-
-  const a = plan.actions.find(x => (x as any).connection?.source === 'mes-miratek') as any
-  assert.equal(a?.action, 'update', `갱신이 아니라 ${a?.action} 이다`)
-  assert.ok(a.keptSecrets?.includes('token'), '이미 있는 토큰을 지킨다고 말하지 않는다')
-})
-
-test('★ 패키지가 아닌 것을 받으면 아무것도 하지 않는다', () => {
-  for (const bad of [null, {}, { kind: 'something-else' }, 'text']) {
-    const plan = planImport(bad, [], () => false)
-    assert.equal(plan.actions.length, 0, `${JSON.stringify(bad)} 로 무언가를 하려 했다`)
-    assert.ok(plan.errors.length, '왜 안 되는지 말하지 않는다')
-  }
-})
-
-test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  const b = exportConnections([row()], { at: '2026-09-05T00:00:00.000Z' })
-  assert.equal(b.connections.length, 1, '패키지가 비었다 — 이 검사가 아무것도 안 잰다')
-  assert.ok(planImport(b, [], () => true).actions.length > 0, '계획이 비었다')
-})