@things-factory/worklist 10.1.202 → 10.1.205

package/tests/pick-race.pg.test.ts

@@ -7,7 +7,8 @@ import { join } from 'path'
  * between. Runs only when WORKLIST_PG_URL names a postgres server (see discard-versus-issue.pg.test.ts).
  *
  * A case waiting for one person must end with one thread, whoever wins; and one person pressing twice
- * must not hold it twice.
+ * must not hold it twice. A case in a pool waits with one unassigned thread: whoever takes it, by pick or
+ * by claim, takes that thread, and nothing is left waiting once the case has its people.
  */
 
 const url = process.env.WORKLIST_PG_URL
@@ -23,6 +24,7 @@ maybe('picking at once, on postgres', () => {
   const { ActivityThread } = require(join(DIST, 'service', 'activity-thread', 'activity-thread.js'))
   const { ActivityApproval } = require(join(DIST, 'service', 'activity-approval', 'activity-approval.js'))
   const { pick } = require(join(DIST, 'controllers', 'activity-instance', 'pick.js'))
+  const { start } = require(join(DIST, 'controllers', 'activity-thread', 'start.js'))
   const { Domain } = require('@things-factory/shell')
   const { Role, User } = require('@things-factory/auth-base')
 
@@ -63,7 +65,7 @@ maybe('picking at once, on postgres', () => {
       name: `p${round}`,
       state: 'issued',
       activity,
-      assigneeRole: role,
+      assigneeRoles: [role],
       threadsMin: 1,
       threadsMax: 1
     })
@@ -111,7 +113,7 @@ maybe('picking at once, on postgres', () => {
         name: `two${round}`,
         state: 'issued',
         activity,
-        assigneeRole: role,
+        assigneeRoles: [role],
         threadsMin: 2,
         threadsMax: 2
       })
@@ -125,4 +127,80 @@ maybe('picking at once, on postgres', () => {
       expect(await threadsOf(instance)).toBe(2)
     }
   }, 120000)
+
+  /** The shape issue() and a pool assign make: the pool, threadsMin, one unassigned thread. */
+  const aPoolCase = async (name: string, threadsMin: number) => {
+    const instance = await db.getRepository(ActivityInstance).save({
+      domain,
+      name,
+      state: 'issued',
+      activity,
+      assigneeRoles: [role],
+      threadsMin,
+      threadsMax: threadsMin
+    })
+    const waiting = await db.getRepository(ActivityThread).save({ domain, activityInstance: instance, state: 'unassigned' })
+    return { instance, waiting }
+  }
+
+  const statesOf = async (instance: any) =>
+    (await db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id } } }))
+      .map((thread: any) => [thread.state, thread.assigneeId || null])
+      .sort((a: any, b: any) => String(a).localeCompare(String(b)))
+
+  it('two members picking a pool case that waits for one: one holds the waiting thread, nothing is left waiting', async () => {
+    for (let round = 0; round < 20; round++) {
+      const { instance, waiting } = await aPoolCase(`pool${round}`, 1)
+
+      const results = await Promise.allSettled([
+        db.transaction((tx: any) => pick(instance.id, as(first)(tx))),
+        db.transaction((tx: any) => pick(instance.id, as(second)(tx)))
+      ])
+
+      const won = results.findIndex(one => one.status === 'fulfilled')
+      expect(results.filter(one => one.status === 'fulfilled').length).toBe(1)
+      expect((results[won] as any).value.id).toBe(waiting.id)
+      expect(await statesOf(instance)).toEqual([['assigned', [first, second][won].id]])
+    }
+  }, 120000)
+
+  it('a pick and a claim of the waiting thread at once: exactly one wins, and it holds the one thread', async () => {
+    const endings: string[] = []
+
+    for (let round = 0; round < 20; round++) {
+      const { instance, waiting } = await aPoolCase(`claim${round}`, 1)
+
+      const [picked, claimed] = await Promise.allSettled([
+        db.transaction((tx: any) => pick(instance.id, as(first)(tx))),
+        db.transaction((tx: any) => start(waiting.id, {}, '', as(second)(tx)))
+      ])
+      endings.push(`pick ${picked.status} · claim ${claimed.status}`)
+
+      expect([picked.status, claimed.status].filter(status => status === 'fulfilled').length).toBe(1)
+      expect(await statesOf(instance)).toEqual(
+        picked.status === 'fulfilled' ? [['assigned', first.id]] : [['started', second.id]]
+      )
+    }
+
+    console.log('endings', [...new Set(endings)].join(' · '))
+  }, 120000)
+
+  it('two members picking a pool case that waits for two: both hold a thread, nothing is left waiting', async () => {
+    for (let round = 0; round < 10; round++) {
+      const { instance } = await aPoolCase(`pool-two${round}`, 2)
+
+      const results = await Promise.allSettled([
+        db.transaction((tx: any) => pick(instance.id, as(first)(tx))),
+        db.transaction((tx: any) => pick(instance.id, as(second)(tx)))
+      ])
+
+      expect(results.map(one => one.status)).toEqual(['fulfilled', 'fulfilled'])
+      expect(await statesOf(instance)).toEqual(
+        [
+          ['assigned', first.id],
+          ['assigned', second.id]
+        ].sort((a: any, b: any) => String(a).localeCompare(String(b)))
+      )
+    }
+  }, 120000)
 })

package/tests/pool-pick-waiting-thread.test.ts

@@ -0,0 +1,254 @@
+import { join } from 'path'
+
+/**
+ * A pool's waiting thread, taken by pick or by claim (2026-10-20).
+ *
+ * A case in a role's pool carries one unassigned thread, and the to-do list of every pool holder reads that
+ * thread (my-open-threads.ts). Pick made a new assigned thread beside it and left it there, so a case one
+ * member had taken stayed on everyone else's list. The rule now, whichever door is used:
+ *
+ *   - the taker gets the waiting thread itself;
+ *   - while the case still waits for more people (fewer valid threads than threadsMin), one waiting thread is
+ *     left for the rest of the pool, and none once it has enough;
+ *   - one person holds one thread of a case - a second take is refused by name, and the waiting thread is off
+ *     the list of whoever already holds one.
+ *
+ * Real entities on sqlite, as assign-role-pool.test.ts.
+ */
+
+/* Nobody here manages activity instances - the role is the only way in. */
+jest.mock('@things-factory/auth-base', () => {
+  const actual = jest.requireActual('@things-factory/auth-base')
+  return { ...actual, checkPermission: async () => false }
+})
+
+const { createSqliteTestDataSource } = require(join(__dirname, '..', '..', 'ops-master', 'test', 'support', 'database.cjs'))
+const DIST = join(__dirname, '..', 'dist-server')
+const { Activity } = require(join(DIST, 'service', 'activity', 'activity.js'))
+const { ActivityInstance } = require(join(DIST, 'service', 'activity-instance', 'activity-instance.js'))
+const { ActivityThread } = require(join(DIST, 'service', 'activity-thread', 'activity-thread.js'))
+const { ActivityApproval } = require(join(DIST, 'service', 'activity-approval', 'activity-approval.js'))
+const { myOpenThreadsWhere } = require(join(DIST, 'service', 'activity-thread', 'my-open-threads.js'))
+const { assign } = require(join(DIST, 'controllers', 'activity-instance', 'assign.js'))
+const { issue } = require(join(DIST, 'controllers', 'activity-instance', 'issue.js'))
+const { pick } = require(join(DIST, 'controllers', 'activity-instance', 'pick.js'))
+const { start } = require(join(DIST, 'controllers', 'activity-thread', 'start.js'))
+const { Domain } = require('@things-factory/shell')
+const { Role, User } = require('@things-factory/auth-base')
+
+let db: any
+let here: any
+let manager: any
+let first: any
+let second: any
+let third: any
+let outsider: any
+let pool: any
+let elsewhere: any
+let activity: any
+
+beforeAll(async () => {
+  db = createSqliteTestDataSource([Activity, ActivityInstance, ActivityThread, ActivityApproval])
+  await db.initialize()
+
+  here = await db.getRepository(Domain).save({ name: 'here', subdomain: 'here' })
+
+  const person = (name: string) =>
+    db.getRepository(User).save({ name, email: `${name}@example.com`, password: 'x', status: 'activated', userType: 'user', domains: [here] })
+
+  manager = await person('manager')
+  first = await person('first')
+  second = await person('second')
+  third = await person('third')
+  outsider = await person('outsider')
+
+  pool = await db.getRepository(Role).save({ domain: here, name: 'finance', users: [first, second, third] })
+  elsewhere = await db.getRepository(Role).save({ domain: here, name: 'support', users: [outsider] })
+
+  activity = await db.getRepository(Activity).save({ domain: here, name: 'tax-invoice', activityType: 'standard', startingType: 'issue' })
+})
+
+afterAll(async () => db?.destroy())
+
+const as = (user: any, tx: any) => ({ state: { domain: here, user, tx }, t: (key: string) => key }) as any
+
+const pickAs = (user: any, instance: any) => db.transaction((tx: any) => pick(instance.id, as(user, tx)))
+const claimAs = (user: any, thread: any) => db.transaction((tx: any) => start(thread.id, {}, '', as(user, tx)))
+
+const reread = (instance: any) => db.getRepository(ActivityInstance).findOneBy({ id: instance.id })
+
+/** [state, holder] of every thread of the case, holders by name, in a fixed order. */
+const threadsOf = async (instance: any) => {
+  const threads = await db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id } } })
+  const names = new Map([first, second, third, outsider, manager].map((user: any) => [user.id, user.name]))
+  return threads.map((thread: any) => [thread.state, names.get(thread.assigneeId) || null]).sort((a: any, b: any) => String(a).localeCompare(String(b)))
+}
+
+const waitingOf = async (instance: any) =>
+  (await db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id }, state: 'unassigned' } }))[0]
+
+/** How many times the case is on this person's to-do list - the list's own condition (my-open-threads.ts). */
+const onTheListOf = (user: any, roles: any[], instance: any) =>
+  db
+    .getRepository(ActivityThread)
+    .createQueryBuilder('at')
+    .innerJoin('at.activityInstance', 'ai')
+    .where(myOpenThreadsWhere({ userId: user.id, roles: roles.map(role => role.id) }))
+    .andWhere('ai.id = :id', { id: instance.id })
+    .getCount()
+
+/** The case as each pool member and the outsider see it on their lists. */
+const lists = async (instance: any) => ({
+  first: await onTheListOf(first, [pool], instance),
+  second: await onTheListOf(second, [pool], instance),
+  third: await onTheListOf(third, [pool], instance),
+  outsider: await onTheListOf(outsider, [elsewhere], instance)
+})
+
+const issued = (threadsMin: number) =>
+  db.transaction((tx: any) => issue({ activityId: activity.id, assignees: [], assigneeRoles: [pool], threadsMin }, as(manager, tx)))
+
+const assigned = async () => {
+  const instance = await db.getRepository(ActivityInstance).save({ domain: here, name: 'case', state: 'issued', activity })
+  await db.transaction((tx: any) => assign({ id: instance.id, assigneeRoles: [pool.id] }, as(manager, tx)))
+  return instance
+}
+
+describe('a pool waiting for one person', () => {
+  it.each([
+    ['issued with an assignee role', () => issued(1)],
+    ['put in a pool by assign', assigned]
+  ])('%s, picked by a member: the waiting thread is theirs, and the rest of the pool no longer sees the case', async (_, made) => {
+    const instance = await made()
+    const [waiting] = await threadsOf(instance)
+    expect(waiting).toEqual(['unassigned', null])
+
+    await pickAs(first, instance)
+
+    expect(await threadsOf(instance)).toEqual([['assigned', 'first']])
+    expect((await reread(instance)).state).toBe('assigned')
+    expect(await lists(instance)).toEqual({ first: 1, second: 0, third: 0, outsider: 0 })
+  })
+
+  it('pick returns the waiting thread itself, now held', async () => {
+    const instance = await issued(1)
+    const waiting = await waitingOf(instance)
+
+    const picked = await pickAs(first, instance)
+
+    expect(picked.id).toBe(waiting.id)
+    expect([picked.state, picked.assigneeId]).toEqual(['assigned', first.id])
+  })
+
+  it('a second member picking after it is refused by name and the case is left as it was', async () => {
+    const instance = await issued(1)
+    await pickAs(first, instance)
+
+    await expect(pickAs(second, instance)).rejects.toThrow('error.activity-instance should not be assigned')
+    expect(await threadsOf(instance)).toEqual([['assigned', 'first']])
+  })
+
+  it('claimed by a member: as before, one thread, theirs, off the rest of the pool', async () => {
+    const instance = await issued(1)
+
+    await claimAs(first, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([['started', 'first']])
+    expect(await lists(instance)).toEqual({ first: 1, second: 0, third: 0, outsider: 0 })
+  })
+
+  it('a case with no waiting thread is picked as before - a new thread for the picker', async () => {
+    const instance = await db.getRepository(ActivityInstance).save({
+      domain: here,
+      name: 'bare',
+      state: 'issued',
+      activity,
+      assigneeRoles: [pool],
+      threadsMin: 1
+    })
+
+    await pickAs(first, instance)
+
+    expect(await threadsOf(instance)).toEqual([['assigned', 'first']])
+  })
+})
+
+describe('a pool waiting for two people (threadsMin 2)', () => {
+  it('the first pick takes the waiting thread and leaves one for the rest; the second fills it and none is left', async () => {
+    const instance = await issued(2)
+    expect(await threadsOf(instance)).toEqual([['unassigned', null]])
+
+    await pickAs(first, instance)
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['unassigned', null]
+    ])
+    expect((await reread(instance)).state).toBe('unassigned')
+    /* first sees their own thread once - not the pool's waiting thread beside it. */
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 1, outsider: 0 })
+
+    await pickAs(second, instance)
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['assigned', 'second']
+    ])
+    expect((await reread(instance)).state).toBe('assigned')
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 0, outsider: 0 })
+  })
+
+  it('the same by claiming the waiting thread each time', async () => {
+    const instance = await issued(2)
+
+    await claimAs(first, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([
+      ['started', 'first'],
+      ['unassigned', null]
+    ])
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 1, outsider: 0 })
+
+    await claimAs(second, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([
+      ['started', 'first'],
+      ['started', 'second']
+    ])
+    expect(await lists(instance)).toEqual({ first: 1, second: 1, third: 0, outsider: 0 })
+  })
+
+  it('one picks, the next claims: two holders, nothing left waiting', async () => {
+    const instance = await issued(2)
+
+    await pickAs(first, instance)
+    await claimAs(second, await waitingOf(instance))
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['started', 'second']
+    ])
+  })
+
+  it('someone who holds a thread already is refused by name a second one, by pick or by claim', async () => {
+    const instance = await issued(2)
+    await pickAs(first, instance)
+
+    await expect(pickAs(first, instance)).rejects.toThrow('error.activity-instance already yours')
+    await expect(claimAs(first, await waitingOf(instance))).rejects.toThrow('error.activity-instance already yours')
+
+    expect(await threadsOf(instance)).toEqual([
+      ['assigned', 'first'],
+      ['unassigned', null]
+    ])
+  })
+
+  it('someone outside the pool is refused the waiting thread, and it stays waiting', async () => {
+    const instance = await issued(2)
+
+    await expect(pickAs(outsider, instance)).rejects.toThrow('error.activity-instance is addressed to another role')
+    await expect(claimAs(outsider, await waitingOf(instance))).rejects.toThrow('error.not authorized to handle this task')
+
+    expect(await threadsOf(instance)).toEqual([['unassigned', null]])
+  })
+})

package/tests/published-shape.test.ts

@@ -54,9 +54,9 @@ beforeEach(() => (seen.length = 0))
 const handed = (name: string, on: string) => seen.find(one => one.name === name && one.on === on)?.entity
 
 it('a new instance carries its domain, its maker and the role it waits for', async () => {
-  await db.getRepository(ActivityInstance).save({ domain, name: 'i', creator: user, assigneeRole: role, state: 'issued' })
+  await db.getRepository(ActivityInstance).save({ domain, name: 'i', creator: user, assigneeRoles: [role], state: 'issued' })
 
-  expect(handed('ActivityInstance', 'insert')).toMatchObject({ domainId: domain.id, creatorId: user.id, assigneeRoleId: role.id })
+  expect(handed('ActivityInstance', 'insert')).toMatchObject({ domainId: domain.id, creatorId: user.id, assigneeRoleIds: [role.id] })
 })
 
 it('a new thread carries its domain and its assignee', async () => {

package/tests/role-pool-race.pg.test.ts

@@ -0,0 +1,182 @@
+import { join } from 'path'
+
+/**
+ * Putting a case in a role's pool at the same moment as something else, on postgres (ADR-0091 decision 9).
+ *
+ * Every way into a waiting case takes the case's row first and its threads after - pick, a pool assign,
+ * a member claiming the pool's waiting thread. sqlite holds one connection and cannot run two transactions
+ * side by side, so what it says about this is no evidence either way. Runs only when WORKLIST_PG_URL names a
+ * postgres server (see discard-versus-issue.pg.test.ts):
+ *
+ *   docker run -d --name wl-ux-pg -e POSTGRES_PASSWORD=wlux -e POSTGRES_USER=wlux -e POSTGRES_DB=wlux \
+ *     -p 55433:5432 postgres:14-alpine
+ *   WORKLIST_PG_URL=postgres://wlux:wlux@localhost:55433/wlux npx jest packages/worklist/tests/role-pool-race.pg.test.ts
+ *
+ * Each round must end one way or the other, and whoever lost is refused by name - a deadlock, two waiting
+ * threads, a pool wiped by a stale save, or someone outside the role holding the case is the defect.
+ */
+
+const url = process.env.WORKLIST_PG_URL
+const maybe = url ? describe : describe.skip
+
+/* Nobody here manages activity instances - the role is the only way in. */
+jest.mock('@things-factory/auth-base', () => {
+  const actual = jest.requireActual('@things-factory/auth-base')
+  return { ...actual, checkPermission: async () => false }
+})
+
+maybe('a role pool at the same moment as something else, on postgres', () => {
+  const { DataSource } = require('typeorm')
+  const { entityClosure } = require(join(__dirname, '..', '..', 'ops-master', 'test', 'support', 'database.cjs'))
+  const { NamingStrategy } = require('@things-factory/shell/dist-server/initializers/naming-strategy.js')
+  const DIST = join(__dirname, '..', 'dist-server')
+  const { Activity } = require(join(DIST, 'service', 'activity', 'activity.js'))
+  const { ActivityInstance } = require(join(DIST, 'service', 'activity-instance', 'activity-instance.js'))
+  const { ActivityThread } = require(join(DIST, 'service', 'activity-thread', 'activity-thread.js'))
+  const { ActivityApproval } = require(join(DIST, 'service', 'activity-approval', 'activity-approval.js'))
+  const { assign } = require(join(DIST, 'controllers', 'activity-instance', 'assign.js'))
+  const { pick } = require(join(DIST, 'controllers', 'activity-instance', 'pick.js'))
+  const { start } = require(join(DIST, 'controllers', 'activity-thread', 'start.js'))
+  const { Domain } = require('@things-factory/shell')
+  const { Role, User } = require('@things-factory/auth-base')
+
+  /* The refusals a loser may get - by name, never a deadlock or a constraint error. */
+  const NAMED = [
+    'error.activity-approval taken by someone else',
+    'error.activity-instance is addressed to another role',
+    'error.activity-instance should not be assigned',
+    'error.not authorized to handle this task'
+  ]
+
+  let db: any
+  let domain: any
+  let manager: any
+  let finance: any
+  let support: any
+  let inFinance: any
+  let inSupport: any
+  let outsider: any
+  let activity: any
+
+  beforeAll(async () => {
+    db = new DataSource({
+      type: 'postgres',
+      url,
+      synchronize: true,
+      dropSchema: true,
+      entities: entityClosure([Activity, ActivityInstance, ActivityThread, ActivityApproval]),
+      namingStrategy: new NamingStrategy()
+    })
+    await db.initialize()
+
+    domain = await db.getRepository(Domain).save({ name: 'd', subdomain: 'd' })
+    const person = (name: string) =>
+      db.getRepository(User).save({ name, email: `${name}@example.com`, password: 'x', status: 'activated', userType: 'user', domains: [domain] })
+    manager = await person('manager')
+    inFinance = await person('in-finance')
+    inSupport = await person('in-support')
+    outsider = await person('outsider')
+    finance = await db.getRepository(Role).save({ domain, name: 'finance', users: [inFinance] })
+    support = await db.getRepository(Role).save({ domain, name: 'support', users: [inSupport] })
+    activity = await db.getRepository(Activity).save({ domain, name: 'tax-invoice', activityType: 'standard', startingType: 'issue' })
+  }, 60000)
+
+  afterAll(async () => db?.destroy())
+
+  const as = (user: any) => (tx: any) => ({ state: { domain, user, tx }, t: (key: string) => key }) as any
+  const aCase = (name: string) => db.getRepository(ActivityInstance).save({ domain, name, state: 'issued', activity })
+  const threadsOf = (instance: any) => db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id } } })
+  const reread = (instance: any) => db.getRepository(ActivityInstance).findOne({ where: { id: instance.id }, relations: ['assigneeRoles'] })
+  const poolOf = (row: any) => (row?.assigneeRoles || []).map((role: any) => role.id).sort()
+  const toPool = (instance: any, role: any) => (tx: any) => assign({ id: instance.id, assigneeRoles: [role.id] }, as(manager)(tx))
+
+  /** Every loser was refused by one of the named refusals. */
+  const refusedByName = (results: PromiseSettledResult<any>[]) =>
+    results
+      .filter(one => one.status === 'rejected')
+      .forEach((one: any) => expect(NAMED).toContain(one.reason?.message))
+
+  it('two pool assigns at once: one waiting thread, in one of the two pools', async () => {
+    const endings: string[] = []
+
+    for (let round = 0; round < 20; round++) {
+      const instance = await aCase(`two-${round}`)
+
+      const results = await Promise.allSettled([db.transaction(toPool(instance, finance)), db.transaction(toPool(instance, support))])
+      refusedByName(results)
+
+      const threads = await threadsOf(instance)
+      const after = await reread(instance)
+      endings.push(`${results.filter(one => one.status === 'fulfilled').length} won`)
+
+      expect(threads.map((thread: any) => thread.state)).toEqual(['unassigned'])
+      expect([[finance.id], [support.id]]).toContainEqual(poolOf(after))
+      expect(after.threadsMin).toBe(1)
+    }
+
+    console.log('endings', [...new Set(endings)].join(' · '))
+  }, 120000)
+
+  it('a pool assign and a pick by someone outside the role at once: exactly one wins', async () => {
+    const endings: string[] = []
+
+    for (let round = 0; round < 20; round++) {
+      const instance = await aCase(`pick-${round}`)
+
+      const [assigned, picked] = await Promise.allSettled([
+        db.transaction(toPool(instance, finance)),
+        db.transaction((tx: any) => pick(instance.id, as(outsider)(tx)))
+      ])
+      refusedByName([assigned, picked])
+
+      const threads = await threadsOf(instance)
+      const after = await reread(instance)
+      endings.push(`assign ${assigned.status} · pick ${picked.status}`)
+
+      expect([assigned.status, picked.status].filter(status => status === 'fulfilled').length).toBe(1)
+
+      if (picked.status === 'fulfilled') {
+        expect(threads.map((thread: any) => [thread.state, thread.assigneeId])).toEqual([['assigned', outsider.id]])
+        expect(poolOf(after)).toEqual([])
+      } else {
+        expect(threads.map((thread: any) => thread.state)).toEqual(['unassigned'])
+        expect(poolOf(after)).toEqual([finance.id])
+      }
+    }
+
+    console.log('endings', [...new Set(endings)].join(' · '))
+  }, 120000)
+
+  it('moving a pool while a member of it claims the waiting thread: exactly one wins', async () => {
+    const endings: string[] = []
+
+    for (let round = 0; round < 20; round++) {
+      const instance = await aCase(`claim-${round}`)
+      await db.transaction(toPool(instance, finance))
+      const [waiting] = await threadsOf(instance)
+
+      const [moved, claimed] = await Promise.allSettled([
+        db.transaction(toPool(instance, support)),
+        db.transaction((tx: any) => start(waiting.id, {}, '', as(inFinance)(tx)))
+      ])
+      refusedByName([moved, claimed])
+
+      const threads = await threadsOf(instance)
+      const after = await reread(instance)
+      endings.push(`move ${moved.status} · claim ${claimed.status}`)
+
+      expect([moved.status, claimed.status].filter(status => status === 'fulfilled').length).toBe(1)
+      expect(threads.length).toBe(1)
+
+      if (claimed.status === 'fulfilled') {
+        expect([threads[0].state, threads[0].assigneeId]).toEqual(['started', inFinance.id])
+        expect(poolOf(after)).toEqual([finance.id])
+      } else {
+        expect([threads[0].state, threads[0].assigneeId || null]).toEqual(['unassigned', null])
+        expect(poolOf(after)).toEqual([support.id])
+      }
+    }
+
+    console.log('endings', [...new Set(endings)].join(' · '))
+  }, 120000)
+})

package/tests/work-door.test.ts

@@ -154,18 +154,18 @@ describe('work door standing', () => {
    * 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 } }))
+    const door = judgeDoor(assignment('작업 지시 배정', { installed: { assigneeRoles: [] } }))
 
     assert.equal(door.standing, 'off')
     assert.equal(door.reason, 'no-assignee')
   })
 
   it('reads a bound role as standing and names it', () => {
-    const door = judgeDoor(assignment('정비 배정', { installed: { assigneeRole: 'MAINTENANCE-LEAD' } }))
+    const door = judgeDoor(assignment('정비 배정', { installed: { assigneeRoles: ['MAINTENANCE-LEAD', 'SHIFT-LEAD'] } }))
 
     assert.equal(door.standing, 'on')
     assert.equal(door.reason, 'assignee-bound')
-    assert.equal(door.assigneeRole, 'MAINTENANCE-LEAD')
+    assert.deepEqual(door.assigneeRoles, ['MAINTENANCE-LEAD', 'SHIFT-LEAD'])
   })
 
   /** An approval line on an assignment door is not what fills it, and must not read as standing. */

package/translations/en.json

@@ -34,10 +34,16 @@
   "error.activity-approval taken by someone else": "someone else handled this approval first. reload the list to see where it stands.",
   "error.activity-instance belongs to someone else": "{id} is someone else's draft. Only the person who wrote it, or someone who manages activity instances, may edit or issue it.",
   "error.activity-instance is addressed to another role": "{id} is assigned to another role. only someone with that role can pick it.",
+  "error.activity-instance already yours": "you already hold this task ({id}).",
   "error.activity-instance is already issued": "this task ({id}) has already been issued with the {state} status.",
   "error.activity-instance is already terminated": "this task ({id}) has already been terminated with the {state} status.",
   "error.activity-instance approval line is set": "this task already has its approval line; it is set on the task's detail screen.",
   "error.activity-instance assignee not in this domain": "these are not people of this site: {emails}",
+  "error.activity-instance a role is not an assignee": "a role cannot be an assignee - it would go to one person of the role. to give it to anyone of the role, set the assignee role.",
+  "error.activity-instance assign people or a role, not both": "assign it to people or to a role, not both at once.",
+  "error.activity-instance role not in this domain": "this role is not of this site: {role}",
+  "error.activity-instance assignee role named twice": "the same role is named more than once: {role}. name each role once.",
+  "error.activity-instance role has no members": "nobody holds the role {role}, so nobody would see this task. add people to the role first.",
   "error.activity-instance draft is gone": "this draft went out or was thrown away in the meantime. please read the list again.",
   "error.activity-instance not found": "this task ({activityInstance}) cannot be found.",
   "error.activity-instance not a draft any more": "this draft has already gone out, so it cannot be thrown away.",

package/translations/es.json

@@ -34,10 +34,16 @@
   "error.activity-approval taken by someone else": "otra persona resolvió esta aprobación antes. vuelva a cargar la lista para ver su estado.",
   "error.activity-instance belongs to someone else": "{id} es un borrador de otra persona. Solo quien lo redactó, o quien gestiona las instancias de actividad, puede editarlo o emitirlo.",
   "error.activity-instance is addressed to another role": "{id} está asignado a otro rol. solo alguien con ese rol puede seleccionarlo.",
+  "error.activity-instance already yours": "ya tiene esta tarea ({id}).",
   "error.activity-instance is already issued": "esta tarea ({id}) ya se emitió con el estado {state}.",
   "error.activity-instance is already terminated": "esta tarea ({id}) ya finalizó con el estado {state}.",
   "error.activity-instance approval line is set": "esta tarea ya tiene su línea de aprobación; se configura en la pantalla de detalle de la tarea.",
   "error.activity-instance assignee not in this domain": "estas personas no pertenecen a este sitio: {emails}",
+  "error.activity-instance a role is not an assignee": "un rol no puede ser asignado: llegaría a una sola persona del rol. para dárselo a cualquiera del rol, indique el rol asignado.",
+  "error.activity-instance assign people or a role, not both": "asígnelo a personas o a un rol, no a ambos a la vez.",
+  "error.activity-instance role not in this domain": "este rol no pertenece a este sitio: {role}",
+  "error.activity-instance assignee role named twice": "el mismo rol aparece más de una vez: {role}. indique cada rol una sola vez.",
+  "error.activity-instance role has no members": "nadie tiene el rol {role}, así que nadie vería esta tarea. añada personas al rol primero.",
   "error.activity-instance draft is gone": "este borrador se envió o se descartó mientras tanto. vuelva a cargar la lista.",
   "error.activity-instance not found": "no se encuentra esta tarea ({activityInstance}).",
   "error.activity-instance not a draft any more": "este borrador ya se envió, así que no se puede descartar.",

package/translations/ja.json

@@ -34,10 +34,16 @@
   "error.activity-approval taken by someone else": "他の方が先に処理しました。一覧を再読み込みしてください。",
   "error.activity-instance belongs to someone else": "{id} is someone else's draft. Only the person who wrote it, or someone who manages activity instances, may edit or issue it.",
   "error.activity-instance is addressed to another role": "{id} は別の役割に割り当てられた業務です。その役割を持つ人だけが選択できます。",
+  "error.activity-instance already yours": "この業務({id})はすでに担当しています。",
   "error.activity-instance is already issued": "このタスク({id})はすでに{state}状態で発行されています。",
   "error.activity-instance is already terminated": "このタスク({id})はすでに{state}状態で終了しています。",
   "error.activity-instance approval line is set": "この業務は決裁ラインが決まっています。決裁ラインは業務詳細で変更します。",
   "error.activity-instance assignee not in this domain": "このサイトの人ではありません: {emails}",
+  "error.activity-instance a role is not an assignee": "割当者に役割は指定できません。役割の一人にしか届きません。その役割の誰にでも任せるには割当役割を指定してください。",
+  "error.activity-instance assign people or a role, not both": "人か役割のどちらか一方に割り当ててください。",
+  "error.activity-instance role not in this domain": "このサイトの役割ではありません: {role}",
+  "error.activity-instance assignee role named twice": "同じ役割が複数回指定されています: {role}。役割はそれぞれ一度だけ指定してください。",
+  "error.activity-instance role has no members": "役割 {role} に人がいないため、誰もこの業務を見られません。先に役割に人を追加してください。",
   "error.activity-instance draft is gone": "この下書きはその間に発行されたか破棄されました。一覧を読み直してください。",
   "error.activity-instance not found": "このタスク({activityInstance})が見つかりません。",
   "error.activity-instance not a draft any more": "この下書きはすでに発行されたため、破棄できません。",