@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/source-outcome-audit.test.ts

@@ -1,104 +0,0 @@
-/*
- * **허락과 일어남 사이를 같은 행에 닫는다** — ADR-0029 §1 결정 C (2026-08-19).
- *
- * ── 무엇이 열려 있었나 ──────────────────────────────────────────────────────
- * 명령이 원본으로 가면 감사는 「허락했다」까지만 증명한다: 어댑터가 오류 없이 실패하면 원장에는 승인만 남는다.
- * 그리고 구동 문(`controlTwinSource`)은 감사를 **아예 남기지 않았다** — 자극을 바꾸고 배속을 올리는 것은
- * 그 트윈의 사실을 바꾸는 행위인데, 나중에 「무엇이 이 공장을 흔들었나」에 답할 수 없었다.
- *
- * ── 세 값을 구별한다 ────────────────────────────────────────────────────────
- *  · 칸이 **없음** — 원본에 묻지 않았다(커널이 받은 명령).
- *  · `unknown` — 물었는데 답이 없다. **성공으로 적지 않는다.**
- *  · `applied`·`refused` — 원본이 답했다(둘 다 사실이다).
- *
- * 셋을 뭉개면 둘 중 하나가 된다: 일어난 일을 없던 일로 만들거나, 없던 일을 일어난 일로 만든다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { buildCommandAudit, sourceOutcomeOf } from '../server/service/twin-audit/command-audit.ts'
-
-const at = new Date('2026-08-19T05:00:00.000Z')
-
-test('묻지 않았으면 칸을 만들지 않는다 — 커널이 받은 명령이 그렇다', () => {
-  const row = buildCommandAudit({ command: { type: 'order.hold', origin: 'user' }, ack: { accepted: true }, at })
-  assert.equal('sourceOutcome' in row, false, '없음은 「모른다」가 아니라 「묻지 않았다」다')
-  assert.equal('sourceCode' in row, false)
-})
-
-test('물었는데 답이 없으면 unknown — 성공으로 적지 않는다', () => {
-  const row = buildCommandAudit({
-    command: { type: 'source.stimulus', origin: 'user' },
-    ack: { accepted: true },
-    source: { answered: false },
-    at
-  })
-  assert.equal(row.sourceOutcome, 'unknown')
-})
-
-test('답이 있으면 그대로 적는다 — 거절도 사실이다', () => {
-  const applied = buildCommandAudit({ command: {}, ack: { accepted: true }, source: { answered: true, ok: true }, at })
-  assert.equal(applied.sourceOutcome, 'applied')
-  const refused = buildCommandAudit({
-    command: {},
-    ack: { accepted: true },
-    source: { answered: true, ok: false, code: 'not-declared' },
-    at
-  })
-  assert.equal(refused.sourceOutcome, 'refused')
-  assert.equal(refused.sourceCode, 'not-declared', '원본이 준 사유를 그대로 적는다')
-})
-
-test('사유가 없으면 사유 칸도 없다 — 지어내지 않는다', () => {
-  const row = buildCommandAudit({ command: {}, ack: { accepted: true }, source: { answered: true, ok: true }, at })
-  assert.equal('sourceCode' in row, false)
-})
-
-test('판정 함수가 세 값만 낸다 — ok 가 참/거짓이 아니면 모른다', () => {
-  assert.equal(sourceOutcomeOf({ answered: true, ok: true }), 'applied')
-  assert.equal(sourceOutcomeOf({ answered: true, ok: false }), 'refused')
-  assert.equal(sourceOutcomeOf({ answered: false }), 'unknown')
-  assert.equal(sourceOutcomeOf({ answered: true }), 'unknown', '답했다고 하면서 값이 없으면 모르는 것이다')
-  assert.equal(sourceOutcomeOf({ answered: true, ok: undefined as any }), 'unknown')
-})
-
-test('신원은 여전히 서버만 채운다 — 원본의 답이 그 규율을 흔들지 않는다', () => {
-  const row = buildCommandAudit({
-    command: { type: 'source.pause', origin: 'user', actorId: 'forged', actorEmail: 'forged@x' },
-    ack: { accepted: true },
-    source: { answered: true, ok: true },
-    at,
-    actor: { id: 'u1', email: 'real@x' }
-  })
-  assert.equal(row.actorId, 'u1')
-  assert.equal(row.actorEmail, 'real@x')
-})
-
-/*
- * ── 구동 문이 실제로 남기는지 (소스로 지킨다) ───────────────────────────────
- * 순수 함수만 시험하면 「기록을 만들 수 있다」까지만 지킨다. 남기지 않으면 그 함수는 아무 일도 하지 않는다.
- */
-test('구동 문이 게이트 뒤에서 원본의 답까지 남긴다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/twin-control/twin-control-mutation.ts', import.meta.url)), 'utf-8')
-  const code = src
-    .split('\n')
-    .filter(line => !/^\s*(\*|\/\/|\/\*)/.test(line))
-    .join('\n')
-  /* 게이트는 남는다(결정 C 의 절반). */
-  const gates = code.match(/@privilege\(category: "twin", privilege: "mutation"/g) ?? []
-  assert.ok(gates.length >= 2, `구동 문에도 게이트가 있어야 한다(발견 ${gates.length})`)
-  /* 원본의 답을 같은 행에 닫는다. */
-  assert.match(code, /source: \{ answered: typeof result\?\.ok === 'boolean', ok: result\?\.ok, code: result\?\.code \}/)
-  assert.match(code, /type: `source\.\$\{action\}`/, '커맨드 채널과 같은 어휘로 적는다')
-  /* 기록 실패를 삼키지 않는다. */
-  assert.match(code, /source control audit not recorded/)
-})
-
-test('엔티티가 그 두 칸을 든다 — 비어 있음이 뜻을 갖는다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/service/twin-audit/twin-audit-event.ts', import.meta.url)), 'utf-8')
-  assert.match(src, /sourceOutcome\?: string/)
-  assert.match(src, /sourceCode\?: string/)
-  assert.match(src, /the source was not asked/, '비어 있음의 뜻을 필드 설명이 말한다')
-})

package/test/space-integrity.test.ts

@@ -1,223 +0,0 @@
-/*
- * 공간 ↔ 트윈 ↔ 가시화 정합성 — 어긋난 모양마다 하나씩 세운다.
- *
- * 검사가 **무는지** 확인하는 것이 이 파일의 일이다: 정합한 입력에서는 아무것도 내지 않고, 어긋난
- * 입력에서는 그 자리를 코드와 id 로 지목해야 한다. 지목하지 못하면 사람이 어디를 볼지 알 수 없다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { checkSpaceIntegrity, sortFindings, type SpaceIntegrityInput } from '../server/service/twin-space/space-integrity.ts'
-
-/** 정합한 한 현장 — 트윈 하나(창고), 지도 표현 하나, 구역 하나, 폴리곤이 그 구역과 로케이션을 가리킨다. */
-const SOUND: SpaceIntegrityInput = {
-  spaces: [{ spaceId: 'rosarito-site', primaryRepresentationId: 'rep-map' }],
-  instances: [
-    {
-      instanceId: 'wms-a',
-      spaceId: 'rosarito-site',
-      modelSpaceId: 'rosarito-site',
-      locationIds: ['rack-1', 'dock-1'],
-      equipmentIds: ['fork-1'],
-      areaRefs: ['bldg-1']
-    }
-  ],
-  representations: [
-    {
-      id: 'rep-map',
-      spaceId: 'rosarito-site',
-      type: 'map',
-      polygons: [
-        { id: 'p1', groupId: 'bldg-1' },
-        { id: 'p2', targetKind: 'location', targetId: 'rack-1' },
-        { id: 'p3', targetKind: 'equipment', targetId: 'fork-1' }
-      ]
-    }
-  ],
-  areasBySpace: { 'rosarito-site': ['bldg-1'] },
-  boardIds: []
-}
-
-test('정합하면 아무것도 내지 않는다 — 멀쩡한 현장을 시끄럽게 만들지 않는다', () => {
-  assert.deepEqual(checkSpaceIntegrity(SOUND), [])
-})
-
-test('없는 현장을 가리키는 트윈을 잡는다 — 무대가 사라진 트윈', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [{ ...SOUND.instances[0], spaceId: 'gone-site', modelSpaceId: 'gone-site' }]
-  })
-  const hit = f.find(x => x.code === 'twin-space-missing')
-  assert.ok(hit)
-  assert.equal(hit.severity, 'broken')
-  assert.equal(hit.instanceId, 'wms-a')
-  assert.equal(hit.spaceId, 'gone-site')
-})
-
-test('레지스트리와 model 의 현장이 다르면 잡는다 — 어느 쪽이 사실인지 알 수 없다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [{ ...SOUND.instances[0], modelSpaceId: 'other-site' }]
-  })
-  const hit = f.find(x => x.code === 'twin-space-mismatch')
-  assert.ok(hit)
-  assert.equal(hit.severity, 'broken')
-  assert.equal(hit.params?.registry, 'rosarito-site')
-  assert.equal(hit.params?.model, 'other-site')
-})
-
-test('현장 없는 트윈은 경고로 낸다 — 뗀 결과일 수 있어 고장은 아니다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [{ ...SOUND.instances[0], spaceId: undefined, modelSpaceId: undefined }]
-  })
-  const hit = f.find(x => x.code === 'twin-without-space')
-  assert.ok(hit)
-  assert.equal(hit.severity, 'warn')
-})
-
-test('로케이션이 이 현장에 없는 구역에 소속되어 있으면 잡는다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [{ ...SOUND.instances[0], areaRefs: ['bldg-1', 'floor-9', 'floor-9'] }]
-  })
-  const hit = f.find(x => x.code === 'location-area-missing')
-  assert.ok(hit)
-  assert.equal(hit.params?.count, 1, '중복은 한 번만 센다')
-  assert.equal(hit.params?.areas, 'floor-9')
-})
-
-test('폴리곤이 없는 구역을 가리키면 잡는다 — 그 도형은 아무것도 보여 주지 않는다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    representations: [{ ...SOUND.representations[0], polygons: [{ id: 'p1', groupId: 'ghost-area' }] }]
-  })
-  const hit = f.find(x => x.code === 'polygon-area-missing')
-  assert.ok(hit)
-  assert.equal(hit.severity, 'broken')
-  assert.equal(hit.representationId, 'rep-map')
-  assert.equal(hit.params?.areaId, 'ghost-area')
-})
-
-test('폴리곤이 이 현장의 어느 트윈에도 없는 로케이션을 가리키면 잡는다 — 트윈을 옮긴 뒤 남는 모양', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [{ ...SOUND.instances[0], spaceId: 'other-site', modelSpaceId: 'other-site' }],
-    spaces: [...SOUND.spaces, { spaceId: 'other-site' }]
-  })
-  const hits = f.filter(x => x.code === 'polygon-target-missing')
-  assert.equal(hits.length, 2, '로케이션과 설비 둘 다 끊긴다')
-  assert.equal(hits[0].severity, 'broken')
-  assert.equal(hits.find(h => h.params?.kind === 'equipment')?.params?.targetId, 'fork-1')
-})
-
-test('설비 바인딩을 로케이션 목록으로 판정하지 않는다 — 종류를 섞으면 거짓 경보가 난다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    representations: [
-      { ...SOUND.representations[0], polygons: [{ id: 'p3', targetKind: 'equipment', targetId: 'rack-1' }] }
-    ]
-  })
-  assert.ok(f.find(x => x.code === 'polygon-target-missing'), '로케이션 id 를 설비로 가리키면 끊긴 것이다')
-})
-
-test('대표 표현이 이 현장의 것이 아니면 잡는다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    spaces: [{ spaceId: 'rosarito-site', primaryRepresentationId: 'rep-elsewhere' }]
-  })
-  const hit = f.find(x => x.code === 'primary-representation-missing')
-  assert.ok(hit)
-  assert.equal(hit.severity, 'broken')
-})
-
-test('보드 표현이 보드를 가리키지 않으면 잡는다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    representations: [{ id: 'rep-board', spaceId: 'rosarito-site', type: 'board', boardId: null, polygons: [] }],
-    spaces: [{ spaceId: 'rosarito-site', primaryRepresentationId: 'rep-board' }]
-  })
-  const hit = f.find(x => x.code === 'board-representation-unbound')
-  assert.ok(hit)
-  assert.equal(hit.params?.boardId, '—')
-})
-
-test('없는 보드를 가리키는 보드 표현도 잡는다', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    representations: [{ id: 'rep-board', spaceId: 'rosarito-site', type: 'board', boardId: 'gone', polygons: [] }],
-    spaces: [{ spaceId: 'rosarito-site', primaryRepresentationId: 'rep-board' }],
-    boardIds: ['other-board']
-  })
-  assert.ok(f.find(x => x.code === 'board-representation-unbound'))
-})
-
-test('트윈이 사는데 표현이 없으면 경고한다 — 볼 화면이 없다', () => {
-  const f = checkSpaceIntegrity({ ...SOUND, representations: [], spaces: [{ spaceId: 'rosarito-site' }] })
-  const hit = f.find(x => x.code === 'space-without-representation')
-  assert.ok(hit)
-  assert.equal(hit.params?.twins, 1)
-})
-
-test('트윈이 없는 빈 현장은 정상이다 — 만들어 두고 아직 안 쓴 현장', () => {
-  const f = checkSpaceIntegrity({
-    spaces: [{ spaceId: 'empty-site' }],
-    instances: [],
-    representations: [],
-    areasBySpace: {},
-    boardIds: []
-  })
-  assert.deepEqual(f, [])
-})
-
-test('벤치 사본은 검사 대상이 아니다 — 잠깐 살고 지워지는 사본', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [
-      ...SOUND.instances,
-      { instanceId: 'bench-1', spaceId: 'nowhere-site', modelSpaceId: 'else', purpose: 'bench' }
-    ]
-  })
-  assert.deepEqual(f, [], '사본의 어긋남은 세지 않는다')
-})
-
-test('심각한 것이 먼저 온다 — 사람이 무엇부터 볼지 정하지 않아도 되게', () => {
-  const f = sortFindings([
-    { code: 'twin-without-space', severity: 'warn', message: 'w' },
-    { code: 'twin-space-missing', severity: 'broken', message: 'b' }
-  ])
-  assert.equal(f[0].severity, 'broken')
-})
-
-/*
- * ── 어휘가 맞지 않는 트윈 (2026-08-14, EMS 를 붙이며) ────────────────────────
- *
- * 커널은 모르는 `eventType` 을 버리고 종류별로 센다(`state.unhandled`). 그 수가 0이 아니면 저널은
- * 들어오는데 상태가 채워지지 않는 것이고, 화면에는 「정상인데 빈」 트윈으로 보인다.
- *
- * 이 검사가 지키는 것은 **모른다와 없다의 구별**이다: 정지한 트윈은 확인한 바가 없으므로 세지 않는다.
- */
-test('담을 줄 모르는 어휘가 들어오는 트윈을 잡는다 — 리비전만 오르는 빈 트윈', () => {
-  const f = checkSpaceIntegrity({
-    ...SOUND,
-    instances: [{ ...SOUND.instances[0], unhandled: [{ eventType: 'energy.measured', count: 96 }, { eventType: 'energy.peak', count: 4 }] }]
-  })
-  const hit = f.find(x => x.code === 'twin-unhandled-vocabulary')!
-  assert.ok(hit, '이것을 놓치면 사용자는 커넥터가 잘못 붙은 것을 알 수 없다')
-  assert.equal(hit.severity, 'warn')
-  assert.equal(hit.instanceId, 'wms-a', '어느 트윈인지 지목해야 한다')
-  assert.equal(hit.params?.events, 100, '건수를 합쳐 낸다')
-  assert.equal(hit.params?.kinds, 2)
-  assert.match(String(hit.params?.types), /energy\.measured/, '많은 것부터 이름을 낸다')
-})
-
-test('정지한 트윈은 세지 않는다 — 확인하지 않은 것을 정합으로도 결함으로도 세지 않는다', () => {
-  /* `unhandled` 가 undefined 인 것은 「없다」가 아니라 「모른다」다(런타임이 없으면 알 수 없다). */
-  const f = checkSpaceIntegrity(SOUND)
-  assert.equal(f.find(x => x.code === 'twin-unhandled-vocabulary'), undefined)
-})
-
-test('빈 배열은 결함이 아니다 — 받은 것이 없으면 들어온 것이 없다', () => {
-  const f = checkSpaceIntegrity({ ...SOUND, instances: [{ ...SOUND.instances[0], unhandled: [] }] })
-  assert.equal(f.find(x => x.code === 'twin-unhandled-vocabulary'), undefined)
-})

package/test/space-representation.test.ts

@@ -1,66 +0,0 @@
-/*
- * ★ 표현을 묶고 가른다 — 목록에 나올 것과 다른 표현에서 열리는 것.
- *
- * ── 왜 (2026-08-27 · 사용자 지시, UX 레인 요청) ─────────────────────────────
- * 「각 표현이 많아지게 되면 관리가 어려우니, 그루핑과 정렬 기능도 필요하다.」
- * 「표현 인덱스에 포함될 표현과 팝업 같은 파생 표현이 구분될 수 있어야 한다.」
- *
- * 칸 둘을 더한다.
- *
- *   group   자유 문자열. 묶는 축이 현장마다 다르다(건물별·용도별·층별)
- *   role    index(기본) · derived. 닫힌 목록이다
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { REPRESENTATION_ROLES } from '../server/service/twin-space/representation-role.js'
-
-const dir = (...p: string[]) => join(import.meta.dirname, '..', 'server', 'service', 'twin-space', ...p)
-const entity = readFileSync(dir('twin-space-representation.ts'), 'utf8')
-const resolver = readFileSync(dir('twin-space-resolver.ts'), 'utf8')
-
-test('★ 묶는 이름은 자유 문자열이다 — 묶는 축이 현장마다 다르다', () => {
-  assert.match(entity, /group\?: string/, 'group 칸이 있어야 한다')
-  /* 고정 목록으로 두면 현장마다 맞지 않는다 — 값을 검사하지 않는다. */
-  assert.doesNotMatch(resolver, /GROUPS as readonly|REPRESENTATION_GROUPS/, '묶는 이름을 목록으로 닫지 않는다')
-})
-
-test('★ 그룹 자체의 순서는 칸으로 두지 않는다 — 그 그룹의 최소 seq 가 그 순서다', () => {
-  /* 칸을 두면 그룹 이름을 바꿀 때 두 곳을 맞춰야 하고, 어긋나면 목록 순서가 오류 없이 달라진다. */
-  assert.doesNotMatch(entity, /groupSeq|groupOrder/, '그룹 순서 칸을 만들지 않는다')
-})
-
-test('★ role 은 닫힌 목록이고, 모르는 값은 저장하지 않는다', () => {
-  assert.deepEqual([...REPRESENTATION_ROLES], ['index', 'derived'])
-  /*
-   * 모르는 값을 그냥 저장하면 화면이 그것을 어느 쪽으로도 그리지 못하고, 그 표현이 목록에서 알리지 않고
-   * 사라진다. 저장하는 자리에서 거절한다.
-   */
-  assert.match(resolver, /REPRESENTATION_ROLES as readonly string\[\]\)\.includes\(role\)/, '닫힌 목록으로 검사한다')
-  assert.match(resolver, /unknown representation role/, '거절 사유를 말한다')
-})
-
-test('★ 비어 있으면 index 다 — 흔한 쪽을 기본으로 둔다', () => {
-  assert.match(entity, /role\?: string/, 'role 은 선택 칸이다')
-  assert.match(entity, /default when absent/, '비어 있을 때의 뜻이 설명에 있어야 한다')
-  /* 공백만 있는 값은 「없음」과 같다 — 그것을 값으로 저장하면 검사를 지나며 뜻이 없는 값이 남는다. */
-  assert.match(resolver, /String\(rep\.role\)\.trim\(\) === ''/, '공백만 있는 값은 비운다')
-  assert.match(resolver, /String\(rep\.group\)\.trim\(\) === ''/, '묶는 이름도 같다')
-})
-
-test('★ isPrimary 에 얹지 않는다 — 다른 질문에 답하는 칸이다', () => {
-  /*
-   * `isPrimary` 는 「현장 현황에 나올 하나」를 정한다. `role` 은 「목록에 나오나」를 정한다. 한 칸이
-   * 두 질문에 답하면 한쪽을 고칠 때 다른 쪽이 오류 없이 바뀐다.
-   */
-  assert.match(entity, /isPrimary\?: boolean/, 'isPrimary 는 그대로 있어야 한다')
-  assert.match(entity, /Kept separate from isPrimary/, '왜 따로 두는지 설명에 있어야 한다')
-})
-
-test('★ 조회가 두 값을 실어 보낸다 — 화면이 묶을 수 있어야 한다', () => {
-  assert.match(resolver, /group: rep\.group, role: rep\.role/, '표현 목록에 두 값을 싣는다')
-  assert.match(resolver, /order: \{ group: 'ASC', seq: 'ASC' \}/, '묶은 이름 다음에 순서로 정렬한다')
-  /* 빈 값이 앞에 오는지 뒤에 오는지는 드라이버마다 다르다 — 그 순서에 기대지 않는다. */
-  assert.match(resolver, /드라이버마다\s*\n?\s*\*?\s*다르므로/, '그 순서에 기대지 않는다는 것을 적어 둔다')
-})

package/test/space-scope-includes-stopped.test.ts

@@ -1,55 +0,0 @@
-/*
- * ★ 현장으로 물으면 멈춘 트윈의 기록도 나온다 — 저널은 기록이고, 지금 도는지는 다른 축이다.
- *
- * ── 무엇이 났나 (2026-08-28 실측) ───────────────────────────────────────────
- * 대상 해소에 `running` 조건이 있었다. 그래서 현장으로 물으면 멈춘 트윈이 대상에서 빠지고, 화면은
- * 「기록이 없습니다」라고 말했다 — 저널에는 있는데.
- *
- *   twinEventList(instanceId: "ems-plant-1")      1,792건
- *   twinEventList(spaceId:    "ems-plant-1-site")     0건   ← 같은 트윈 · 같은 도메인
- *
- * 규모로 보면 예외가 아니라 기본값이었다: 등록된 트윈 30개 중 도는 것 2개, 멈춘 것 28개.
- *
- * ── 왜 지웠나 ──────────────────────────────────────────────────────────────
- * 옛 주석이 대는 이유(「벤치 사본은 사용자가 보는 현장이 아니다」)는 벤치 제외만 설명한다. `running` 에는
- * 근거가 적혀 있지 않았다. 그리고 바로 다음 줄이 반대 원칙을 적어 두었다 — 「정지·비등록이어도 저널은
- * 남아 있을 수 있다」. 그 원칙이 현장 경로에만 적용되지 않고 있었다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-const KPI = join(import.meta.dirname, '..', 'server', 'engine', 'kpi-query.ts')
-const src = readFileSync(KPI, 'utf8')
-
-/** 대상을 고르는 그 한 줄만 떼어 본다. */
-const targetLine = (() => {
-  const from = src.indexOf('async function resolveTargets')
-  const body = src.slice(from, from + 1200)
-  const m = /: list\.filter\(\(x: any\) => [^\n]+\)/.exec(body)
-  return m?.[0] ?? ''
-})()
-
-test('★ 현장 경로가 「지금 도는가」로 걸러내지 않는다', () => {
-  assert.ok(targetLine, '대상을 고르는 줄을 찾아야 한다')
-  assert.doesNotMatch(targetLine, /running/, '멈춘 트윈을 현장에서 빼면 화면이 거짓 「없다」를 낸다')
-})
-
-test('벤치 사본은 계속 뺀다 — 그 제외에는 근거가 있다', () => {
-  /* 부하 시험용 사본은 사용자가 보는 현장이 아니다. 이 제외는 지우지 않는다. */
-  assert.match(targetLine, /purpose !== 'bench'/)
-})
-
-test('현장과 트윈 두 경로가 같은 원칙을 쓴다 — 저널은 기록이다', () => {
-  /* 트윈을 지정한 경로는 처음부터 「정지·비등록이어도 저널은 남아 있을 수 있다」였다. */
-  assert.match(src, /정지·비등록\)? ?지정된 트윈은 그대로 조회한다|정지·비등록/)
-  /* 왜 지웠는지가 코드에 남아 있어야 한다 — 다음 사람이 성능을 이유로 되넣지 않게. */
-  assert.match(src, /「지금 도는가」로 걸러내지 않는다/)
-  assert.match(src, /1,792건/, '무엇을 재서 알았는지 적혀 있어야 한다')
-})
-
-test('★ 「지금 도는 것만」이 필요하면 이름 있는 축으로 받는다 — 여기 숨기지 않는다', () => {
-  /* 한 칸에 두 물음을 담으면 어느 화면이 무엇을 보는지 아무도 모른다. */
-  assert.match(src, /\*\*이름 있는 축\*\*으로 받는다/)
-})

package/test/spec-coverage.test.ts

@@ -1,113 +0,0 @@
-/*
- * 시뮬 명세 자격 판정 — **"이 예측으로 무엇을 말할 수 있나" 를 숫자로 가른다.**
- *
- * 배경: 공정 소요가 커널 상수였을 때와 현장 명세로 굴렸을 때가 응답에서 똑같이 "p50 168" 로 보였다.
- * 그 둘을 구별하지 못하면 상대 비교용 숫자가 절대 예측처럼 읽힌다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { classifySpecCoverage, readSpecCoverage } from '../server/engine/spec-coverage.ts'
-
-test('전부 기본값이면 상대 비교만 — 절대 시각을 주장할 근거가 없다', () => {
-  const r = classifySpecCoverage({
-    operations: [
-      { kind: 'putaway', duration: 'default' },
-      { kind: 'pick', duration: 'default' }
-    ]
-  })
-  assert.equal(r!.qualification, 'relative')
-  assert.equal(r!.declaredDurations, 0)
-  assert.equal(r!.defaultDurations, 2)
-})
-
-test('전부 선언되면 절대 예측 시도 가능 — 단 정확도는 별개(이름이 capable 이다)', () => {
-  const r = classifySpecCoverage({
-    operations: [
-      { kind: 'cut', duration: 'declared', variability: 'triangular', parameters: ['yield'] },
-      { kind: 'weld', duration: 'declared', variability: 'uniform' }
-    ]
-  })
-  assert.equal(r!.qualification, 'absolute-capable')
-  assert.equal(r!.varyingDurations, 2)
-})
-
-test('섞이면 partial — 한쪽만 계산하지된 사실을 감추지 않는다', () => {
-  const r = classifySpecCoverage({
-    operations: [
-      { kind: 'cut', duration: 'declared' },
-      { kind: 'paint', duration: 'default' }
-    ]
-  })
-  assert.equal(r!.qualification, 'partial')
-  assert.equal(r!.declaredDurations, 1)
-  assert.equal(r!.defaultDurations, 1)
-})
-
-test('변동 없는 선언은 varying 0 — 고정값이면 대기·병목이 과소평가된다는 신호', () => {
-  const r = classifySpecCoverage({ operations: [{ kind: 'cut', duration: 'declared' }] })
-  assert.equal(r!.varyingDurations, 0)
-  const c = classifySpecCoverage({ operations: [{ kind: 'cut', duration: 'declared', variability: 'constant' }] })
-  assert.equal(c!.varyingDurations, 0, 'constant 는 변동이 아니다')
-})
-
-test('관측된 작업이 없으면 판정하지 않는다 — 모름을 relative 로 단정하지 않는다', () => {
-  assert.equal(classifySpecCoverage({ operations: [] }), undefined)
-  assert.equal(classifySpecCoverage({} as any), undefined)
-})
-
-test('커널이 보고 API 를 갖지 않으면 undefined — "전부 기본값" 이라 단정하지 않는다', () => {
-  assert.equal(readSpecCoverage({}), undefined)
-  assert.equal(readSpecCoverage(undefined), undefined)
-})
-
-test('커널 보고가 오류를 내어도 예측을 깨지 않는다', () => {
-  assert.equal(readSpecCoverage({ specCoverage: () => { throw new Error('boom') } }), undefined)
-})
-
-test('커널 보고를 그대로 분류한다 — 카운트를 다시 세지 않고 준 값을 존중', () => {
-  const r = readSpecCoverage({
-    specCoverage: () => ({
-      operations: [{ kind: 'cut', duration: 'declared', parameters: ['yield'] }],
-      declaredDurations: 1,
-      defaultDurations: 0
-    })
-  })
-  assert.equal(r!.qualification, 'absolute-capable')
-  assert.deepEqual(r!.operations[0].parameters, ['yield'])
-})
-
-/* ── 실측이 들어오면 자격이 한 칸 올라간다 ─────────────────────────────── */
-
-test('전부 이력에서 온 소요면 calibrated — 선언은 사람이 적은 값, 이것은 일어난 값', () => {
-  const r = classifySpecCoverage({
-    operations: [
-      { kind: 'putaway', duration: 'measured' },
-      { kind: 'pick', duration: 'measured' }
-    ]
-  })
-  assert.equal(r!.qualification, 'calibrated')
-  assert.equal(r!.measuredDurations, 2)
-})
-
-test('실측과 선언이 섞이면 absolute-capable — 상수가 없으면 시각을 말할 수 있다', () => {
-  const r = classifySpecCoverage({
-    operations: [
-      { kind: 'putaway', duration: 'measured' },
-      { kind: 'cut', duration: 'declared' }
-    ]
-  })
-  assert.equal(r!.qualification, 'absolute-capable')
-})
-
-test('상수가 하나라도 섞이면 partial — 실측이 있어도 감추지 않는다', () => {
-  const r = classifySpecCoverage({
-    operations: [
-      { kind: 'putaway', duration: 'measured' },
-      { kind: 'pick', duration: 'default' }
-    ]
-  })
-  assert.equal(r!.qualification, 'partial')
-  assert.equal(r!.measuredDurations, 1)
-  assert.equal(r!.defaultDurations, 1)
-})

package/test/stage-path.test.ts

@@ -1,95 +0,0 @@
-/*
- * ★ 단계 판정 — **체크리스트가 아니라 증거로 센다.**
- *
- * 이 테스트가 지키는 것:
- *  ① **「모른다」는 달성이 아니다.** 계측되지 않은 신호(`null`)를 0 으로 대체하면 「반출 0건」과
- *     「반출을 세지 않았다」가 같아진다. 배선하지 않은 계측으로 단계를 주장할 길을 남기지 않는다.
- *  ② **반출을 세었는데 없으면 라이브가 아니다.** 되풀어 읽는 스냅샷은 원리적으로 반출을 못 낸다 —
- *     이 판별식이 폴링을 「실시간」이라 부르는 것을 막는다.
- *  ③ **선언이 비면 예측이 아니다.** 커널 기본값 위에 선 숫자도 화면에서는 예측처럼 보인다.
- *  ④ **앞을 건너뛸 수 없다.** 뒤 단계는 자기 조건을 따지지 않고 `prerequisite` 으로 막는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { assessStagePath, forbiddenClaims, type StageEvidence } from '../server/engine/stage-path.ts'
-
-/** 전부 달성한 증거 — 각 시험은 여기서 한 축만 무너뜨린다(무엇이 판정을 바꿨는지 분명해진다). */
-const full = (): StageEvidence => ({
-  locationCount: 12,
-  itemCount: 340,
-  masterWarnings: 3,
-  liveIngestTotal: 1200,
-  removalsObserved: 17,
-  forecastRan: true,
-  specCoverage: { declared: 6, total: 8 },
-  actuateCapability: true,
-  correlatedEffectObserved: 2
-})
-
-test('전부 증거가 있으면 폐루프까지 도달하고 금지 표현이 없다', () => {
-  const p = assessStagePath(full())
-  assert.deepEqual(p.stages.map(s => s.achieved), [true, true, true, true])
-  assert.equal(p.reached, 'closed-loop')
-  assert.equal(p.next, null)
-  assert.deepEqual(forbiddenClaims(p), [])
-})
-
-test('못 옮긴 값을 세지 않았으면 구조도 달성이 아니다 — 0 이라고 우기지 않는다', () => {
-  const p = assessStagePath({ ...full(), masterWarnings: null })
-  const s1 = p.stages[0]
-  assert.equal(s1.achieved, false)
-  assert.deepEqual(s1.unmeasured, ['master-warnings'])
-  assert.deepEqual(s1.blockedBy, [], '자리와 물품은 있으므로 막힌 것이 아니라 모르는 것이다')
-  assert.equal(p.reached, null, '첫 칸을 못 밟았으면 서 있는 칸이 없다')
-})
-
-test('못 옮긴 값이 3건이어도 구조는 달성이다 — 요구는 「없다」가 아니라 「말할 수 있다」', () => {
-  assert.equal(assessStagePath({ ...full(), masterWarnings: 3 }).stages[0].achieved, true)
-  assert.equal(assessStagePath({ ...full(), masterWarnings: 0 }).stages[0].achieved, true)
-})
-
-test('반출을 세었는데 0 이면 라이브가 아니다 — 스냅샷 되풀어 읽기의 징표', () => {
-  const p = assessStagePath({ ...full(), removalsObserved: 0 })
-  assert.equal(p.stages[1].achieved, false)
-  assert.deepEqual(p.stages[1].blockedBy, ['no-removal-observed'])
-  assert.equal(p.reached, 'structure')
-  assert.ok(forbiddenClaims(p).includes('claim.realtime'), '실시간이라고 말할 수 없다')
-})
-
-test('반출이 계측되지 않으면 「없다」가 아니라 「모른다」로 막힌다', () => {
-  const p = assessStagePath({ ...full(), removalsObserved: null })
-  assert.deepEqual(p.stages[1].unmeasured, ['removals'])
-  assert.deepEqual(p.stages[1].blockedBy, [], '인제스트는 있으므로 막힌 것이 아니다')
-})
-
-test('선언이 비면 예측이 아니다 — 기본값 위에 선 숫자도 숫자로 보인다', () => {
-  const p = assessStagePath({ ...full(), specCoverage: { declared: 0, total: 8 } })
-  assert.equal(p.stages[2].achieved, false)
-  assert.deepEqual(p.stages[2].blockedBy, ['declarations-empty'])
-  assert.equal(p.reached, 'live')
-  assert.ok(forbiddenClaims(p).includes('claim.prediction'))
-})
-
-test('접수만으로는 폐루프가 아니다 — 효과가 관측으로 돌아와야 닫힌다', () => {
-  const p = assessStagePath({ ...full(), correlatedEffectObserved: 0 })
-  assert.deepEqual(p.stages[3].blockedBy, ['effect-not-observed'])
-  assert.equal(p.reached, 'forecast')
-})
-
-test('앞이 막히면 뒤는 자기 조건을 따지지 않는다 — 순서를 건너뛸 수 없다', () => {
-  const p = assessStagePath({ ...full(), locationCount: 0, itemCount: 0 })
-  assert.deepEqual(p.stages[0].blockedBy, ['no-locations', 'no-items'])
-  for (const later of p.stages.slice(1)) assert.deepEqual(later.blockedBy, ['prerequisite'])
-  assert.deepEqual(p.next, { stage: 'structure', blockedBy: ['no-locations', 'no-items'], unmeasured: [] })
-})
-
-test('다음 걸음은 목록이 아니라 하나다', () => {
-  const p = assessStagePath({ ...full(), removalsObserved: 0, specCoverage: null, actuateCapability: false })
-  assert.equal(p.next?.stage, 'live', '뒤쪽 결손을 함께 들이밀지 않는다')
-})
-
-test('비직렬 수량 물품만 있어도 구조는 달성이다 — 식품·화학은 개수로 오지 않는다', () => {
-  /* itemCount 는 「자리에 놓인 물품 수」이고, 비직렬 수량 물품(subLot)도 한 줄로 센다. */
-  assert.equal(assessStagePath({ ...full(), itemCount: 1 }).stages[0].achieved, true)
-})