@things-factory/worklist 10.1.29 → 10.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "10.1.29",
+  "version": "10.1.32",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -37,14 +37,14 @@
     "@operato/moment-timezone-es": "^10.0.0",
     "@operato/p13n": "^10.0.0",
     "@operato/popup": "^10.15.0",
-    "@things-factory/attachment-base": "^10.1.29",
-    "@things-factory/auth-base": "^10.1.29",
-    "@things-factory/board-service": "^10.1.29",
-    "@things-factory/context-ui": "^10.1.29",
-    "@things-factory/organization": "^10.1.29",
-    "@things-factory/personalization": "^10.1.29",
-    "@things-factory/scheduler-client": "^10.1.29",
-    "@things-factory/shell": "^10.1.29"
+    "@things-factory/attachment-base": "^10.1.31",
+    "@things-factory/auth-base": "^10.1.31",
+    "@things-factory/board-service": "^10.1.31",
+    "@things-factory/context-ui": "^10.1.31",
+    "@things-factory/organization": "^10.1.32",
+    "@things-factory/personalization": "^10.1.31",
+    "@things-factory/scheduler-client": "^10.1.31",
+    "@things-factory/shell": "^10.1.31"
   },
-  "gitHead": "e6bf9dec003fe5e794746aaeb5852b3b50478232"
+  "gitHead": "67b211e001da3a923e562cb048e4691bd961315c"
 }

package/tests/pass-work-door.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Which way a work door goes when its approval line is empty, and what gets written down.
+ *
+ * ── Why each of these ─────────────────────────────────────────────────────
+ * The branch itself was never in one place before: eight doors in operato-plant each read the line
+ * and decided, and none of them wrote anything, so a step skipped for want of an approver left no
+ * trace at all. Joined here, `run` cannot happen without the line being written - so the test that
+ * matters most is that the `run` branch writes exactly one row, with the reason that applies.
+ *
+ * The transaction check is not ceremony: a plain manager commits the row on its own, and then the
+ * log says something happened that the failing work never did.
+ */
+
+/*
+ * The entity is stood in for. Its decorators need `emitDecoratorMetadata`, which babel does not
+ * give jest (the repository's jest config says so, and says to test the pure logic on its own). The
+ * branch under test never reads the class - it only names the repository to save into.
+ */
+jest.mock('../server/service/work-door/work-door-journal.js', () => ({ WorkDoorJournal: class WorkDoorJournal {} }))
+
+import { WorkDoorEvent } from '../server/service/work-door/work-door-event.js'
+import { passWorkDoor } from '../server/service/work-door/pass-work-door.js'
+
+const domain = { id: 'd1' } as any
+
+/** A manager that looks transactional and remembers what was saved. */
+function openTx() {
+  const saved: any[] = []
+
+  return {
+    saved,
+    queryRunner: { isTransactionActive: true },
+    getRepository: () => ({ save: async (row: any) => ((saved.push(row), { ...row, id: 'j1' }) as any) })
+  } as any
+}
+
+const seatsThatStand = { roleHasMembers: async () => true, personIsHere: async () => true }
+
+const approvalDoor = (over: any = {}): any =>
+  ({ name: 'lot-hold-release', labelKey: 'activity.lot-hold-release.label', kind: 'approval', whenNoLine: 'run', ...over } as any)
+
+const subject = { kind: 'lot', id: 'LOT-1' }
+
+describe('passWorkDoor', () => {
+  it('refuses to run outside a transaction - the row would commit on its own', async () => {
+    const loose = { getRepository: () => ({ save: async (r: any) => r }) } as any
+
+    await expect(
+      passWorkDoor({ door: approvalDoor(), subject }, { tx: loose, domain, seats: seatsThatStand })
+    ).rejects.toThrow(/transaction/)
+  })
+
+  it('will not judge an assignment door - it waits for a role, not for a line', async () => {
+    const door = { name: 'job-order-dispatch', labelKey: 'k', kind: 'assignment' } as any
+
+    await expect(passWorkDoor({ door, subject }, { tx: openTx(), domain, seats: seatsThatStand })).rejects.toThrow(
+      /assignment door/
+    )
+  })
+
+  it('raises when the line stands, and writes nothing - the instance is the record', async () => {
+    const tx = openTx()
+    const activity = { approvalLine: [{ type: 'Role', value: 'r1' }] }
+
+    const verdict = await passWorkDoor({ door: approvalDoor(), activity, subject }, { tx, domain, seats: seatsThatStand })
+
+    expect(verdict.go).toBe('raise')
+    expect(tx.saved).toHaveLength(0)
+  })
+
+  it('runs with an empty line, and that is written down once', async () => {
+    const tx = openTx()
+
+    const verdict = await passWorkDoor({ door: approvalDoor(), subject }, { tx, domain, seats: seatsThatStand })
+
+    expect(verdict).toMatchObject({ go: 'run', because: WorkDoorEvent.RanWithoutLine })
+    expect(tx.saved).toHaveLength(1)
+    expect(tx.saved[0]).toMatchObject({
+      kind: WorkDoorEvent.RanWithoutLine,
+      door: 'lot-hold-release',
+      subjectKind: 'lot',
+      subjectId: 'LOT-1'
+    })
+  })
+
+  it('says so differently when the door was declared unused - the administrator has nothing to fix', async () => {
+    const tx = openTx()
+
+    const verdict = await passWorkDoor({ door: approvalDoor(), subject, notUsed: true }, { tx, domain, seats: seatsThatStand })
+
+    expect(verdict).toMatchObject({ go: 'run', because: WorkDoorEvent.RanNotUsed })
+    expect(tx.saved[0].kind).toBe(WorkDoorEvent.RanNotUsed)
+  })
+
+  it('refuses with the line\'s own reason where the door refuses, and writes nothing', async () => {
+    const tx = openTx()
+    const door = approvalDoor({ whenNoLine: 'refuse', because: 'irreversible' } as any)
+
+    const verdict: any = await passWorkDoor({ door, subject }, { tx, domain, seats: seatsThatStand })
+
+    expect(verdict.go).toBe('refuse')
+    expect(verdict.refusal.code).toBe('approval-line-missing')
+    expect(tx.saved).toHaveLength(0)
+  })
+
+  describe('as-established - the row decides, not the door', () => {
+    const door = approvalDoor({ name: 'non-working-withdrawal', whenNoLine: 'as-established', because: 'approval-is-the-act' } as any)
+
+    it('refuses when the row was established through approval', async () => {
+      const tx = openTx()
+
+      const verdict: any = await passWorkDoor(
+        { door, subject, establishedByApproval: true },
+        { tx, domain, seats: seatsThatStand }
+      )
+
+      expect(verdict.go).toBe('refuse')
+      expect(tx.saved).toHaveLength(0)
+    })
+
+    it('runs when it stood without approval', async () => {
+      const tx = openTx()
+
+      const verdict: any = await passWorkDoor(
+        { door, subject, establishedByApproval: false },
+        { tx, domain, seats: seatsThatStand }
+      )
+
+      expect(verdict.go).toBe('run')
+      expect(tx.saved).toHaveLength(1)
+    })
+  })
+})

package/tests/screen-seam.test.ts

@@ -0,0 +1,50 @@
+/**
+ * A screen this module routes to is a screen the shell can actually build.
+ *
+ * ── How this fails, and why nothing says so ───────────────────────────────
+ * Three things have to agree for a page to open: `client/route.ts` maps the page name to an import,
+ * the element registers itself as a custom element, and `things-factory.config.js` carries a
+ * `{ tagname, page }` pair. The shell builds the element from **that pair**. With the first two and
+ * not the third, the route resolves, the element is defined, and the shell puts nothing in the DOM:
+ * a blank screen, no console error, nothing in the server log.
+ *
+ * operato-plant met this twice (2026-09-03 and 2026-09-15; its own config carries a comment saying
+ * so), and the work-door screens met it a third time on the way into this module - the page and its
+ * route came across and the pair did not. Warehouse found it by opening the screen.
+ *
+ * So the agreement is counted here rather than trusted: the config file is data and route.ts names
+ * its cases in plain text, and nobody has to remember the third place.
+ */
+
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const root = join(__dirname, '..')
+
+/** The page names `route()` answers to, read as text - importing it would pull the whole client in. */
+function routedPages(): string[] {
+  const source = readFileSync(join(root, 'client', 'route.ts'), 'utf-8')
+
+  return [...source.matchAll(/case '([^']+)':/g)].map(match => match[1])
+}
+
+/** The pages the shell can build, from the module's declaration. */
+function pagesWithATagname(): string[] {
+  const config = readFileSync(join(root, 'things-factory.config.js'), 'utf-8')
+
+  return [...config.matchAll(/\{\s*tagname:\s*'[^']+',\s*page:\s*'([^']+)'\s*\}/g)].map(match => match[1])
+}
+
+describe('a routed screen can be built', () => {
+  it('reads both sides - an empty reading would let everything pass', () => {
+    expect(routedPages().length).toBeGreaterThanOrEqual(10)
+    expect(pagesWithATagname().length).toBeGreaterThanOrEqual(10)
+  })
+
+  it('★ every page this module routes to has a tagname the shell can build', () => {
+    const buildable = new Set(pagesWithATagname())
+    const blank = routedPages().filter(page => !buildable.has(page))
+
+    expect(blank).toEqual([])
+  })
+})

package/tests/work-door-approval-line-standing.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { judgeApprovalLine, rolesNamedIn } from '../server/service/work-door/approval-line-standing.js'
+
+const role = (value: string, participation?: string) => ({ type: 'Role', value, participation })
+
+/**
+ * 자리를 사람으로 풀어 주는 포트. 이 판단은 DB 를 모르므로 시험도 DB 없이 선다.
+ *
+ * ⚠ `approval-role-empty` 와 `approval-person-absent` 는 **실 자료로 걸어 본 적이 없다.** 역할을
+ * 지목했는데 그 역할이 빈 결재선도, 없는 사람을 지목한 결재선도 지금 어느 테넌트에도 없다 —
+ * 미라텍은 역할이 0이라 결재선을 만들 재료가 없고, system 은 역할마다 사람이 있다. 여기가 그 둘을
+ * 잡는 유일한 자리다.
+ */
+const peopleIn = (...ids: string[]) => ({
+  roleHasMembers: async (roleId: string) => ids.includes(roleId),
+  personIsHere: async (personId: string) => ids.includes(personId)
+})
+
+test('지목한 역할에 사람이 있으면 찬 것이다', async () => {
+  const standing = await judgeApprovalLine([role('r1'), role('r2')], peopleIn('r1', 'r2'))
+
+  assert.deepEqual(standing, { approvers: 2 })
+})
+
+test('결재선 자체가 없으면 approval-line-missing', async () => {
+  assert.deepEqual(await judgeApprovalLine([], peopleIn()), { approvers: 0, refusal: { code: 'approval-line-missing' } })
+  assert.deepEqual(await judgeApprovalLine(undefined, peopleIn()), { approvers: 0, refusal: { code: 'approval-line-missing' } })
+})
+
+/**
+ * 이것이 이 판단을 고친 이유다 — 앞서는 「찼다」로 읽고, 상신하는 순간 워크리스트가 던졌다.
+ */
+test('역할은 있는데 사람이 없으면 approval-role-empty — 어느 역할인지 함께 낸다', async () => {
+  const standing = await judgeApprovalLine([role('r1'), role('r2')], peopleIn('r1'))
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-role-empty', params: { role: 'r2' } } })
+})
+
+test('역할을 지목해 놓고 값이 없으면 찬 것이 아니다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Role' }], peopleIn('r1'))
+
+  assert.ok(standing.refusal, '안 서는 결재선인데 사유가 없습니다')
+})
+
+/*
+ * ── 참조 ───────────────────────────────────────────────────────────────────
+ * 참조는 결재를 막지 않는다. 그래서 세지도 않고, 그 역할이 비었다고 거절하지도 않는다.
+ */
+test('참조 자리는 사람이 없어도 막지 않는다', async () => {
+  const standing = await judgeApprovalLine([role('r1'), role('empty', 'reference')], peopleIn('r1'))
+
+  assert.deepEqual(standing, { approvers: 1 })
+})
+
+test('참조만 있는 결재선은 결재선이 없는 것이다 — 결재 없이 끝난다', async () => {
+  const standing = await judgeApprovalLine([role('r1', 'reference')], peopleIn('r1'))
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-line-missing' } })
+})
+
+test('participation 이 비어 있으면 결재다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Role', value: 'r1' }], peopleIn())
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-role-empty', params: { role: 'r1' } } })
+})
+
+/** 참조 자리의 역할은 **읽지도 않는다** — 읽으면 결재와 무관한 조회가 는다. */
+test('참조 자리의 역할은 묻지 않는다', async () => {
+  const asked: string[] = []
+
+  await judgeApprovalLine([role('r1'), role('r9', 'reference')], {
+    roleHasMembers: async id => {
+      asked.push(id)
+      return true
+    },
+    personIsHere: async () => true
+  })
+
+  assert.deepEqual(asked, ['r1'])
+})
+
+/*
+ * ── 사람을 직접 지목한 자리 ────────────────────────────────────────────────
+ * 「이 제품은 역할만 쓴다」로 닫지 않는다. 닫으면 없는 사람을 지목한 결재선이 「찼다」로 그려지고,
+ * 역할에서 고친 그 모양이 사람 축으로 다시 난다.
+ */
+test('지목한 사람이 있으면 찬 것이다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Employee', value: 'u1' }], peopleIn('u1'))
+
+  assert.deepEqual(standing, { approvers: 1 })
+})
+
+test('지목한 사람이 여기 없으면 approval-person-absent — 누구인지 함께 낸다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Employee', value: 'u1' }], peopleIn())
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-person-absent', params: { personId: 'u1' } } })
+})
+
+/** 상신할 때 그 사람으로 풀리는 자리다. 미리 셀 것이 없다. */
+test('Myself 같은 상대 지목은 미리 묻지 않는다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Myself' }], peopleIn())
+
+  assert.deepEqual(standing, { approvers: 1 })
+})
+
+test('읽어야 할 역할만 골라 낸다 — 참조와 사람 지목은 뺀다', () => {
+  const named = rolesNamedIn([
+    role('r1'),
+    role('r2', 'reference'),
+    { type: 'Employee', value: 'u1' },
+    { type: 'Role' }
+  ])
+
+  assert.deepEqual(named, ['r1'])
+})

package/tests/work-door-door-words.test.ts

@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { DOOR_KIND_WORD, DOOR_STANDING_WORD, kindWord, standingWord } from '../client/pages/work-door/door-words.js'
+
+/*
+ * ═══════════════════════════════════════════════════════════════════════════
+ * registerEnumType puts the enum's MEMBER NAMES on the wire, not their values. So the server sends
+ * "Off" while the judge, the translation keys and the CSS classes all say "off". Nothing throws:
+ * i18next prints the key it could not find, and the class simply never matches.
+ *
+ * Measured on the running server before this was fixed: twelve rows reading
+ * "text.door-standing-Off", and every status pill falling back to the inherited text colour because
+ * .mark.off never matched .mark.Off.
+ *
+ * These tests read the enum out of the server source rather than importing it - that module carries
+ * decorators, which the test harness cannot load.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+const TYPE_SOURCE = readFileSync(
+  join(__dirname, '..', 'server', 'service', 'work-door', 'work-door-type.ts'),
+  'utf-8'
+)
+
+/** `Off = 'off'` → ['Off', 'off'], for the one enum named. */
+function members(enumName: string): [string, string][] {
+  const block = TYPE_SOURCE.split(`export enum ${enumName} {`)[1]
+
+  assert.ok(block, `${enumName} 을 찾지 못했습니다 — 이름이 바뀌었으면 이 시험도 함께 고쳐야 합니다`)
+
+  return [...block.split('\n}')[0].matchAll(/^\s*([A-Za-z]+)\s*=\s*'([^']+)'/gm)].map(one => [one[1], one[2]])
+}
+
+test('every standing the server can send has a word here', () => {
+  const declared = members('DoorStandingValue')
+
+  assert.ok(declared.length >= 4, `상태를 ${declared.length}개만 읽었습니다`)
+
+  for (const [wire, value] of declared) {
+    assert.equal(standingWord(wire), value, `${wire} 이 전선으로 오면 화면이 못 읽습니다`)
+  }
+})
+
+test('every kind the server can send has a word here', () => {
+  const declared = members('DoorKindValue')
+
+  assert.ok(declared.length >= 2, `종류를 ${declared.length}개만 읽었습니다`)
+
+  for (const [wire, value] of declared) {
+    assert.equal(kindWord(wire), value, `${wire} 이 전선으로 오면 화면이 못 읽습니다`)
+  }
+})
+
+test('nothing extra is mapped — a dead entry hides that the server dropped a value', () => {
+  const standings = new Set(members('DoorStandingValue').map(one => one[0]))
+  const kinds = new Set(members('DoorKindValue').map(one => one[0]))
+
+  assert.deepEqual(Object.keys(DOOR_STANDING_WORD).filter(one => !standings.has(one)), [])
+  assert.deepEqual(Object.keys(DOOR_KIND_WORD).filter(one => !kinds.has(one)), [])
+})
+
+test('an unknown spelling answers nothing — the screen must not paint a guess', () => {
+  assert.equal(standingWord('Whatever'), undefined)
+  assert.equal(kindWord('Whatever'), undefined)
+})
+
+/*
+ * The word is not enough on its own: the screen builds `text.door-standing-<word>` and a CSS class
+ * from it. Either one missing is silent.
+ */
+test('every word has a line to show for it, in every language we ship', () => {
+  const missing: string[] = []
+
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms']) {
+    const said = JSON.parse(
+      readFileSync(join(__dirname, '..', 'translations', `${lang}.json`), 'utf-8')
+    ) as Record<string, string>
+
+    for (const word of Object.values(DOOR_STANDING_WORD)) {
+      if (!said[`text.door-standing-${word}`]) missing.push(`${lang} · text.door-standing-${word}`)
+    }
+    for (const word of Object.values(DOOR_KIND_WORD)) {
+      if (!said[`text.door-kind-${word}`]) missing.push(`${lang} · text.door-kind-${word}`)
+    }
+  }
+
+  assert.deepEqual(missing, [], `\n없는 문구는 화면에 키 글자로 뜹니다:\n${missing.join('\n')}`)
+})
+
+test('every word has a colour to paint — a class nothing styles is invisible, not absent', () => {
+  const styles = readFileSync(join(__dirname, '..', 'client', 'pages', 'work-door', 'work-doors-page.ts'), 'utf-8')
+  const missing = Object.values(DOOR_STANDING_WORD).filter(word => !styles.includes(`.${word}`))
+
+  assert.deepEqual(missing, [], `\n이 상태에는 칠할 것이 없습니다: ${missing.join(' · ')}`)
+})

package/tests/work-door.test.ts

@@ -0,0 +1,222 @@
+import { strict as assert } from 'node:assert'
+
+import { doorsToFill, judgeDoor, summarizeDoors } from '../server/service/work-door/work-door.js'
+
+/**
+ * An empty line is a choice, not a defect — but nothing said which doors were in that state.
+ * Miratek had all eleven installed and all eleven empty (measured 2026-09-11), so corrections,
+ * scrapping and dispositions all took effect there with nobody approving.
+ */
+const approval = (label: string, over: object = {}) => ({ name: 'x', label, kind: 'approval' as const, ...over })
+const assignment = (label: string, over: object = {}) => ({ name: 'x', label, kind: 'assignment' as const, ...over })
+
+describe('work door standing', () => {
+  /**
+   * A door that borrows another door's line has no line of its own to fill. If the sentence did not say
+   * so, an administrator would go to that door to fill a line the raise never reads (ADR-0047 ⑨).
+   */
+  it('says where the line is set when a door follows another door', () => {
+    const standing = judgeDoor(
+      approval('통제 해제 승인', {
+        follows: '화면 발행 승인',
+        installed: { approvalLine: [{}] },
+        approvalStanding: { approvers: 1 }
+      })
+    )
+    const empty = judgeDoor(
+      approval('통제 해제 승인', {
+        follows: '화면 발행 승인',
+        installed: {},
+        approvalStanding: { approvers: 0, refusal: { code: 'approval-line-missing' } }
+      })
+    )
+
+    assert.equal(standing.standing, 'on')
+    assert.ok(standing.because.includes('「화면 발행 승인」 의 결재선을 따르므로'))
+    assert.equal(empty.standing, 'off')
+    assert.ok(empty.because.includes('「화면 발행 승인」 의 결재선을 따르므로'), empty.because)
+  })
+
+  it('reads a filled approval line as standing, and says how many it passes', () => {
+    const door = judgeDoor(
+      approval('실적 정정 승인', {
+        installed: { approvalLine: [{}, {}] },
+        approvalStanding: { approvers: 2 }
+      })
+    )
+
+    assert.equal(door.standing, 'on')
+    assert.equal(door.approvers, 2)
+    assert.ok(door.because.includes('결재자 2명'))
+  })
+
+  /**
+   * A line that names a role nobody holds counts as no line at all — the screen used to read it as
+   * standing and the raise then threw `approver is not set` (ADR-0047 ③).
+   */
+  it('reads a role that holds people as standing', () => {
+    const door = judgeDoor(
+      approval('출하 승인', {
+        installed: { approvalLine: [{ type: 'Role', value: 'r1' }] },
+        approvalStanding: { approvers: 1 }
+      })
+    )
+
+    assert.equal(door.standing, 'on')
+    assert.equal(door.approvers, 1)
+  })
+
+  /**
+   * The administrator's next move differs: filling a line is not the same job as putting a person
+   * in a role, and saying the first sends them back to a line they already set.
+   */
+  it('says an empty role needs a person, not a new approval line', () => {
+    const door = judgeDoor(
+      approval('출하 승인', {
+        installed: { approvalLine: [{ type: 'Role', value: 'r1' }] },
+        approvalStanding: { approvers: 0, refusal: { code: 'approval-role-empty', params: { role: 'r1' } } }
+      })
+    )
+
+    assert.equal(door.standing, 'off')
+    assert.equal(door.approvers, 0)
+    assert.ok(door.because.includes('역할에 사람이 없습니다'))
+    assert.ok(!door.because.includes('자기 건을 승인한'))
+  })
+
+  /** A named person who is not here is the same defect on the other axis (ADR-0047 ③). */
+  it('says a named person who is gone needs a different name, not a new line', () => {
+    const door = judgeDoor(
+      approval('출하 승인', {
+        installed: { approvalLine: [{ type: 'Employee', value: 'u1' }] },
+        approvalStanding: { approvers: 0, refusal: { code: 'approval-person-absent', params: { personId: 'u1' } } }
+      })
+    )
+
+    assert.equal(door.standing, 'off')
+    assert.ok(door.because.includes('지목한 사람이 이 공장에 없습니다'))
+    assert.ok(!door.because.includes('자기 건을 승인한'))
+  })
+
+  /** Not having read the line must not read as "the line is filled". */
+  it('treats an unread approval line as empty rather than filled', () => {
+    const door = judgeDoor(approval('출하 승인', { installed: { approvalLine: [{ type: 'Role', value: 'r1' }] } }))
+
+    assert.equal(door.standing, 'off')
+  })
+
+  /**
+   * Worklist completes the instance on issue when the line is empty, so the person raising it has
+   * approved their own. "No approval happens" would be the wrong thing to tell an administrator.
+   */
+  it('says an empty approval line means the raiser approves their own', () => {
+    const door = judgeDoor(approval('폐기 실행 승인', { installed: { approvalLine: [] } }))
+
+    assert.equal(door.standing, 'off')
+    assert.ok(door.because.includes('자기 건을 승인한'))
+  })
+
+  /**
+   * The two kinds fail in opposite directions — an empty approval passes through, an unassigned
+   * door reaches nobody. One shared sentence would leave the reader with the wrong action.
+   */
+  it('says an unassigned door reaches nobody, not that it passes through', () => {
+    const door = judgeDoor(assignment('작업 지시 배정', { installed: { assigneeRole: undefined } }))
+
+    assert.equal(door.standing, 'off')
+    assert.ok(door.because.includes('아무에게도 가지 않습니다'))
+    assert.ok(!door.because.includes('자기 건을 승인'))
+  })
+
+  it('reads a bound role as standing and names it', () => {
+    const door = judgeDoor(assignment('정비 배정', { installed: { assigneeRole: 'MAINTENANCE-LEAD' } }))
+
+    assert.equal(door.standing, 'on')
+    assert.ok(door.because.includes('MAINTENANCE-LEAD'))
+  })
+
+  /** An approval line on an assignment door is not what fills it, and must not read as standing. */
+  it('does not let an approval line stand in for an assignee role', () => {
+    assert.equal(judgeDoor(assignment('배정', { installed: { approvalLine: [{}, {}] } })).standing, 'off')
+  })
+
+  it('treats a line that is absent the same as one that is empty', () => {
+    assert.equal(judgeDoor(approval('Y', { installed: {} })).standing, 'off')
+  })
+
+  /** A door that never installed is our failure, not the plant's choice, and must not read alike. */
+  it('separates a door that never installed from one the plant left empty', () => {
+    const door = judgeDoor(approval('초품 검사 승인'))
+
+    assert.equal(door.standing, 'missing')
+    assert.ok(door.because.includes('세우지 못한 것'))
+  })
+
+  describe('a plant that says it does not use one', () => {
+    /**
+     * Without this the survey nags for ever, and people stop reading it — and then one genuinely
+     * empty door is lost in the nagging (architect, 2026-09-11).
+     */
+    it('reads as not-used and carries the reason', () => {
+      const door = judgeDoor(approval('폐기 실행 승인', { notUsedBecause: '폐기는 본사가 처리합니다' }))
+
+      assert.equal(door.standing, 'not-used')
+      assert.ok(door.because.includes('폐기는 본사가 처리합니다'))
+    })
+
+    /** Said first, or a plant that opted out keeps being told its missing form is a defect. */
+    it('wins over a form that never installed', () => {
+      const door = judgeDoor(approval('폐기 실행 승인', { notUsedBecause: '안 씁니다', installed: undefined }))
+
+      assert.equal(door.standing, 'not-used')
+      assert.ok(!door.because.includes('결함'))
+    })
+
+    it('is never counted as something to fill', () => {
+      const doors = [
+        judgeDoor(approval('a', { notUsedBecause: '안 씁니다' })),
+        judgeDoor(approval('b', { installed: { approvalLine: [] } }))
+      ]
+
+      assert.equal(doorsToFill(doors), 1)
+    })
+  })
+})
+
+describe('summary', () => {
+  const on = judgeDoor(approval('A', { installed: { approvalLine: [{}] }, approvalStanding: { approvers: 1 } }))
+  const off = judgeDoor(approval('B', { installed: { approvalLine: [] } }))
+  const missing = judgeDoor(approval('C'))
+  const notUsed = judgeDoor(approval('D', { notUsedBecause: '안 씁니다' }))
+
+  it('says everything stands when it does', () => {
+    const said = summarizeDoors([on, on])
+
+    assert.ok(said.includes('2개가 다 서 있습니다'))
+    assert.ok(!said.includes('결함'))
+  })
+
+  /** Zero left to fill has to read as done even when some doors were opted out. */
+  it('reads as done when the only unfilled ones were opted out', () => {
+    const said = summarizeDoors([on, notUsed])
+
+    assert.ok(said.includes('채울 것이 남지 않았습니다'))
+    assert.ok(said.includes('1개는 이 공장이 쓰지 않기로'))
+  })
+
+  it('leads with how many are left to fill', () => {
+    const said = summarizeDoors([on, off, off, notUsed])
+
+    assert.ok(said.startsWith('채울 것이 2개 남았습니다.'))
+    assert.ok(said.includes('1개는 이 공장이 쓰지 않기로 한 것이라 세지 않았습니다'))
+  })
+
+  it('names a door that never installed as a defect', () => {
+    assert.ok(summarizeDoors([on, missing]).includes('설정이 아니라 결함'))
+  })
+
+  /** Zero doors is a different fact from "none of them stand" and must not be reported as it. */
+  it('does not report an empty product as a plant with nothing standing', () => {
+    assert.equal(summarizeDoors([]), '이 제품이 세우는 업무 양식이 없습니다.')
+  })
+})

package/things-factory.config.js

@@ -28,6 +28,11 @@ export default {
     { tagname: 'activity-thread-list-page', page: 'activity-thread-list' },
     { tagname: 'installable-activity-list-page', page: 'installable-activity-list' },
     { tagname: 'activity-approval-list-page', page: 'activity-approval-list' },
-    { tagname: 'activity-stats-list-page', page: 'activity-stats-list' }
+    { tagname: 'activity-stats-list-page', page: 'activity-stats-list' },
+    /*
+     * 셸은 이 짝이 있어야 요소를 만든다. `route()` 가 이름을 알아도 여기 없으면 **오류 없이 빈 화면**이다.
+     * operato-plant 가 두 번 밟았고(2026-09-03 · 09-15), 이 화면이 그 제품에서 옮겨 올 때 세 번째였다.
+     */
+    { tagname: 'work-doors-page', page: 'work-doors-page' }
   ]
 }