@things-factory/worklist 10.1.202 → 10.1.205

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "10.1.202",
+  "version": "10.1.205",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "exports": {
@@ -54,15 +54,15 @@
     "@operato/moment-timezone-es": "^10.0.0",
     "@operato/p13n": "^10.29.43",
     "@operato/popup": "^10.29.43",
-    "@things-factory/attachment-base": "^10.1.202",
-    "@things-factory/auth-base": "^10.1.202",
-    "@things-factory/board-service": "^10.1.202",
-    "@things-factory/context-ui": "^10.1.188",
-    "@things-factory/i18n-base": "^10.1.202",
-    "@things-factory/organization": "^10.1.202",
-    "@things-factory/personalization": "^10.1.202",
-    "@things-factory/scheduler-client": "^10.1.202",
-    "@things-factory/shell": "^10.1.188"
+    "@things-factory/attachment-base": "^10.1.205",
+    "@things-factory/auth-base": "^10.1.205",
+    "@things-factory/board-service": "^10.1.205",
+    "@things-factory/context-ui": "^10.1.205",
+    "@things-factory/i18n-base": "^10.1.205",
+    "@things-factory/organization": "^10.1.205",
+    "@things-factory/personalization": "^10.1.205",
+    "@things-factory/scheduler-client": "^10.1.205",
+    "@things-factory/shell": "^10.1.205"
   },
-  "gitHead": "3243b81eb1a4d3d903a01929f3a85d5b8df438dd"
+  "gitHead": "7311492aa5eaa00993c0325053f5f7ae8b1fb024"
 }

package/tests/assign-role-pool.test.ts

@@ -0,0 +1,508 @@
+import { join } from 'path'
+
+/**
+ * A case put in a role's pool by assign, and a role among assignees refused (ruling 2026-10-20).
+ *
+ * The pool is what issue() already makes for an activity that names assignee roles: `assigneeRoles`,
+ * `threadsMin` 1, one unassigned thread. The to-do list reads exactly that, so the check that matters
+ * is the list - a member sees the case, someone else does not. Real entities on sqlite; the race that
+ * the UPDATE closes is staged by handing assign a read taken before someone picked the case.
+ */
+
+/* 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 { checkAuthority } = require(join(DIST, 'controllers', 'activity-thread', 'check-authority.js'))
+const { ActivityMutation } = require(join(DIST, 'service', 'activity', 'activity-mutation.js'))
+const { Domain } = require('@things-factory/shell')
+const { Role, User } = require('@things-factory/auth-base')
+
+let db: any
+let here: any
+let elsewhere: any
+let manager: any
+let member: any
+let other: any
+let pool: any
+let anotherPool: any
+let emptyPool: any
+let alsoEmpty: any
+let both: any
+let theirPool: 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' })
+  elsewhere = await db.getRepository(Domain).save({ name: 'elsewhere', subdomain: 'elsewhere' })
+
+  const person = (name: string, domain: any) =>
+    db.getRepository(User).save({ name, email: `${name}@example.com`, password: 'x', status: 'activated', userType: 'user', domains: [domain] })
+
+  manager = await person('manager', here)
+  member = await person('member', here)
+  other = await person('other', here)
+  both = await person('both', here)
+  const theirs = await person('theirs', elsewhere)
+
+  pool = await db.getRepository(Role).save({ domain: here, name: 'finance', users: [member, both] })
+  anotherPool = await db.getRepository(Role).save({ domain: here, name: 'support', users: [other, both] })
+  emptyPool = await db.getRepository(Role).save({ domain: here, name: 'nobody', users: [] })
+  alsoEmpty = await db.getRepository(Role).save({ domain: here, name: 'nobody-either', users: [] })
+  theirPool = await db.getRepository(Role).save({ domain: elsewhere, name: 'theirs', users: [theirs] })
+
+  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 aCase = (fields: any = {}) =>
+  db.getRepository(ActivityInstance).save({ domain: here, name: 'case', state: 'issued', activity, ...fields })
+
+const assignAs = (user: any, args: any) => db.transaction((tx: any) => assign(args, as(user, tx)))
+
+const reread = (instance: any) =>
+  db.getRepository(ActivityInstance).findOne({ where: { id: instance.id }, relations: ['assigneeRoles'] })
+
+/** The pool's role ids, in no particular order - sorted to compare. */
+const poolOf = (row: any) => (row?.assigneeRoles || []).map((role: any) => role.id).sort()
+
+const threadsOf = (instance: any) => db.getRepository(ActivityThread).find({ where: { activityInstance: { id: instance.id } } })
+
+/** The to-do list's own condition (my-open-threads.ts), for one case. */
+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()
+
+/** A transaction whose first read of the case is one taken earlier - someone else wrote in between. */
+const seesTheOldRead = (tx: any, stale: any) => {
+  let given = false
+
+  return new Proxy(tx, {
+    get(target, key) {
+      if (key !== 'getRepository') return Reflect.get(target, key)
+
+      return (entity: any) => {
+        const repository = target.getRepository(entity)
+        if (entity !== ActivityInstance) return repository
+
+        const once = Object.create(repository)
+        once.findOne = async (...args: any[]) => (given ? repository.findOne(...args) : ((given = true), { ...stale }))
+        return once
+      }
+    }
+  })
+}
+
+describe('assign to a role', () => {
+  it('puts a case nobody holds in the pool: the role, one waiting thread, still issued', async () => {
+    const instance = await aCase()
+
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })
+
+    const after = await reread(instance)
+    expect(after.state).toBe('issued')
+    expect(poolOf(after)).toEqual([pool.id])
+    expect(after.threadsMin).toBe(1)
+
+    const threads = await threadsOf(instance)
+    expect(threads.map((thread: any) => thread.state)).toEqual(['unassigned'])
+    expect(threads[0].assigneeId).toBeFalsy()
+  })
+
+  it('a member of the role finds it on their list; someone of another role does not', async () => {
+    const instance = await aCase()
+
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })
+
+    expect(await onTheListOf(member, [pool], instance)).toBe(1)
+    expect(await onTheListOf(other, [anotherPool], instance)).toBe(0)
+  })
+
+  it('a case already in a pool moves to the other pool and keeps its one waiting thread', async () => {
+    const instance = await aCase()
+
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })
+    await assignAs(manager, { id: instance.id, assigneeRoles: [anotherPool.id] })
+
+    expect(poolOf(await reread(instance))).toEqual([anotherPool.id])
+    expect((await threadsOf(instance)).length).toBe(1)
+    expect(await onTheListOf(other, [anotherPool], instance)).toBe(1)
+    expect(await onTheListOf(member, [pool], instance)).toBe(0)
+  })
+
+  it.each(['assigned', 'started', 'unassigned', 'ended', 'draft'])('a case %s is refused by name and left as it was', async state => {
+    const instance = await aCase({ state })
+
+    await expect(assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })).rejects.toThrow(
+      'error.activity-instance should not be assigned'
+    )
+    expect(poolOf(await reread(instance))).toEqual([])
+    expect((await threadsOf(instance)).length).toBe(0)
+  })
+
+  it("another tenant's role is refused by name", async () => {
+    const instance = await aCase()
+
+    await expect(assignAs(manager, { id: instance.id, assigneeRoles: [theirPool.id] })).rejects.toThrow(
+      'error.activity-instance role not in this domain'
+    )
+    expect(poolOf(await reread(instance))).toEqual([])
+  })
+
+  it('a role nobody holds is refused by name - nobody would see the case', async () => {
+    const instance = await aCase()
+
+    await expect(assignAs(manager, { id: instance.id, assigneeRoles: [emptyPool.id] })).rejects.toThrow(
+      'error.activity-instance role has no members'
+    )
+    expect(poolOf(await reread(instance))).toEqual([])
+    expect((await threadsOf(instance)).length).toBe(0)
+  })
+
+  it('people and a role in one call are refused by name', async () => {
+    const instance = await aCase()
+
+    await expect(assignAs(manager, { id: instance.id, assignees: [member.email], assigneeRoles: [pool.id] })).rejects.toThrow(
+      'error.activity-instance assign people or a role, not both'
+    )
+    expect((await threadsOf(instance)).length).toBe(0)
+  })
+
+  it.each(['assigned', 'started', 'submitted', 'ended'])(
+    'a case still marked issued whose thread someone holds (%s) is refused by name and left as it was',
+    async held => {
+      /* The state is worked out again only when a thread changes - a member taking the waiting thread is a step ahead of it. */
+      const instance = await aCase({ assigneeRoles: [pool], threadsMin: 1 })
+      await db.getRepository(ActivityThread).save({ domain: here, activityInstance: instance, assignee: member, state: held })
+
+      await expect(assignAs(manager, { id: instance.id, assigneeRoles: [anotherPool.id] })).rejects.toThrow(
+        'error.activity-approval taken by someone else'
+      )
+      expect(poolOf(await reread(instance))).toEqual([pool.id])
+      expect((await threadsOf(instance)).map((thread: any) => thread.state)).toEqual([held])
+    }
+  )
+
+  it('someone picked it after assign read it: refused by name, no pool, no second thread', async () => {
+    const instance = await aCase()
+    const stale = await db.getRepository(ActivityInstance).findOne({ where: { id: instance.id }, relations: ['activity'] })
+
+    /*
+     * Picked in between: pick took the case first, and its thread is not yet there for this transaction to
+     * read - only the case's UPDATE can tell.
+     */
+    await db.getRepository(ActivityInstance).update({ id: instance.id }, { state: 'assigned' })
+
+    await expect(
+      db.transaction((tx: any) => assign({ id: instance.id, assigneeRoles: [pool.id] }, as(manager, seesTheOldRead(tx, stale))))
+    ).rejects.toThrow('error.activity-approval taken by someone else')
+
+    expect(poolOf(await reread(instance))).toEqual([])
+    expect((await threadsOf(instance)).length).toBe(0)
+  })
+
+  it('makes the very pool issue() makes for an activity naming an assignee role', async () => {
+    const shape = async (instance: any) => {
+      const row = await reread(instance)
+      return {
+        state: row.state,
+        assigneeRoles: poolOf(row),
+        threadsMin: row.threadsMin,
+        threads: (await threadsOf(instance)).map((thread: any) => [thread.state, thread.assigneeId || null]),
+        member: await onTheListOf(member, [pool], instance),
+        other: await onTheListOf(other, [anotherPool], instance)
+      }
+    }
+
+    const issued = await db.transaction((tx: any) =>
+      issue({ activityId: activity.id, assignees: [], assigneeRoles: [pool], threadsMin: 1 }, as(manager, tx))
+    )
+
+    const assigned = await aCase()
+    await assignAs(manager, { id: assigned.id, assigneeRoles: [pool.id] })
+
+    expect(await shape(assigned)).toEqual(await shape(issued))
+    expect(await shape(assigned)).toMatchObject({ state: 'issued', threads: [['unassigned', null]], member: 1, other: 0 })
+  })
+
+  it('assigning people still works as before', async () => {
+    const instance = await aCase()
+
+    await assignAs(manager, { id: instance.id, assignees: [member.email] })
+
+    const threads = await threadsOf(instance)
+    expect(threads.map((thread: any) => [thread.state, thread.assigneeId])).toEqual([['assigned', member.id]])
+  })
+})
+
+describe('the other ways into a waiting case', () => {
+  const pooled = async () => {
+    const instance = await aCase()
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })
+    return instance
+  }
+
+  it('a member claiming the waiting thread holds the case, and the case says so', async () => {
+    const instance = await pooled()
+    const [waiting] = await threadsOf(instance)
+
+    await db.transaction((tx: any) => start(waiting.id, {}, '', as(member, tx)))
+
+    expect((await threadsOf(instance)).map((thread: any) => [thread.state, thread.assigneeId])).toEqual([['started', member.id]])
+    expect((await reread(instance)).state).not.toBe('issued')
+  })
+
+  it('a claim on a waiting thread someone claimed meanwhile is refused by name, and the thread stays theirs', async () => {
+    const instance = await pooled()
+    const [waiting] = await threadsOf(instance)
+    const stale = { ...waiting }
+
+    await db.getRepository(ActivityThread).update({ id: waiting.id }, { state: 'assigned', assignee: { id: other.id } })
+
+    await expect(db.transaction((tx: any) => checkAuthority(stale, as(member, tx)))).rejects.toThrow(
+      'error.activity-approval taken by someone else'
+    )
+    expect((await threadsOf(instance)).map((thread: any) => thread.assigneeId)).toEqual([other.id])
+  })
+
+  it('pick that read the case before it went to a pool: someone outside the role is refused by name', async () => {
+    const instance = await aCase()
+    const stale = await db.getRepository(ActivityInstance).findOne({ where: { id: instance.id }, relations: ['activity'] })
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })
+
+    await expect(db.transaction((tx: any) => pick(instance.id, as(other, seesTheOldRead(tx, stale))))).rejects.toThrow(
+      'error.activity-instance is addressed to another role'
+    )
+    expect(poolOf(await reread(instance))).toEqual([pool.id])
+  })
+
+  it('pick that read the case before it went to a pool: a member takes it, and the pool is not wiped', async () => {
+    const instance = await aCase()
+    const stale = await db.getRepository(ActivityInstance).findOne({ where: { id: instance.id }, relations: ['activity'] })
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id] })
+
+    await db.transaction((tx: any) => pick(instance.id, as(member, seesTheOldRead(tx, stale))))
+
+    const after = await reread(instance)
+    expect(poolOf(after)).toEqual([pool.id])
+    expect(after.threadsMin).toBe(1)
+  })
+})
+
+describe('a pool of several roles - anyone holding any one of them (ADR-0091 decision 9)', () => {
+  const twoPools = async () => {
+    const instance = await aCase()
+    await assignAs(manager, { id: instance.id, assigneeRoles: [pool.id, anotherPool.id] })
+    return instance
+  }
+
+  it('is one case with one waiting thread, in both pools', async () => {
+    const instance = await twoPools()
+
+    expect(poolOf(await reread(instance))).toEqual([pool.id, anotherPool.id].sort())
+    expect((await threadsOf(instance)).map((thread: any) => thread.state)).toEqual(['unassigned'])
+  })
+
+  it('reaches the to-do list of a holder of either role, once for someone holding both, and nobody else', async () => {
+    const instance = await twoPools()
+
+    expect(await onTheListOf(member, [pool], instance)).toBe(1)
+    /* Only the second role. */
+    expect(await onTheListOf(other, [anotherPool], instance)).toBe(1)
+    expect(await onTheListOf(both, [pool, anotherPool], instance)).toBe(1)
+    expect(await onTheListOf(manager, [emptyPool], instance)).toBe(0)
+  })
+
+  it('someone holding only the second role picks it', async () => {
+    const instance = await twoPools()
+
+    await db.transaction((tx: any) => pick(instance.id, as(other, tx)))
+
+    expect((await threadsOf(instance)).some((thread: any) => thread.assigneeId === other.id)).toBe(true)
+  })
+
+  it('someone holding only the second role claims the waiting thread', async () => {
+    const instance = await twoPools()
+    const [waiting] = await threadsOf(instance)
+
+    await db.transaction((tx: any) => start(waiting.id, {}, '', as(other, tx)))
+
+    expect((await threadsOf(instance)).map((thread: any) => [thread.state, thread.assigneeId])).toEqual([['started', other.id]])
+  })
+
+  it('someone holding none of them is refused the claim', async () => {
+    const instance = await twoPools()
+    const [waiting] = await threadsOf(instance)
+
+    await expect(db.transaction((tx: any) => start(waiting.id, {}, '', as(manager, tx)))).rejects.toThrow(
+      'error.not authorized to handle this task'
+    )
+  })
+
+  it('roles whose people together are nobody are refused by name; one of them with people is enough', async () => {
+    const instance = await aCase()
+
+    await expect(assignAs(manager, { id: instance.id, assigneeRoles: [emptyPool.id, alsoEmpty.id] })).rejects.toThrow(
+      'error.activity-instance role has no members'
+    )
+    expect(poolOf(await reread(instance))).toEqual([])
+
+    await assignAs(manager, { id: instance.id, assigneeRoles: [emptyPool.id, anotherPool.id] })
+    expect(poolOf(await reread(instance))).toEqual([emptyPool.id, anotherPool.id].sort())
+  })
+
+  it('the same role twice is refused by name, and the case is left as it was', async () => {
+    const instance = await aCase()
+
+    await expect(assignAs(manager, { id: instance.id, assigneeRoles: [pool.id, pool.id] })).rejects.toMatchObject({
+      code: 'assignee-role-named-twice'
+    })
+    expect(poolOf(await reread(instance))).toEqual([])
+    expect((await threadsOf(instance)).length).toBe(0)
+  })
+
+  it("another tenant's role among them is refused by name", async () => {
+    const instance = await aCase()
+
+    await expect(assignAs(manager, { id: instance.id, assigneeRoles: [pool.id, theirPool.id] })).rejects.toMatchObject({
+      code: 'assignee-role-not-in-this-domain'
+    })
+    expect(poolOf(await reread(instance))).toEqual([])
+  })
+
+  it('moving a pool of two to a pool of one keeps the one waiting thread', async () => {
+    const instance = await twoPools()
+
+    await assignAs(manager, { id: instance.id, assigneeRoles: [anotherPool.id] })
+
+    expect(poolOf(await reread(instance))).toEqual([anotherPool.id])
+    expect((await threadsOf(instance)).length).toBe(1)
+    expect(await onTheListOf(member, [pool], instance)).toBe(0)
+  })
+
+  it('issued to everyone of the pool (threadsMin 0), each person gets one thread however many of its roles they hold', async () => {
+    const issued = await db.transaction((tx: any) =>
+      issue({ activityId: activity.id, assignees: [], assigneeRoles: [pool, anotherPool], threadsMin: 0 }, as(manager, tx))
+    )
+
+    const holders = (await threadsOf(issued)).map((thread: any) => thread.assigneeId).sort()
+    expect(holders).toEqual([member.id, other.id, both.id].sort())
+  })
+
+  it("an activity's pool of two is the pool of every case issued from it", async () => {
+    const saved = await db.transaction((tx: any) =>
+      new ActivityMutation().createActivity({ name: 'two-pools', assigneeRoles: [{ id: pool.id }, { id: anotherPool.id }] }, as(manager, tx))
+    )
+    const issued = await db.transaction((tx: any) => issue({ activityId: saved.id, assignees: [], threadsMin: 1 }, as(manager, tx)))
+
+    expect(poolOf(await reread(issued))).toEqual([pool.id, anotherPool.id].sort())
+    expect(await onTheListOf(other, [anotherPool], issued)).toBe(1)
+  })
+
+  it.each([
+    ['the same role twice', () => [{ id: pool.id }, { id: pool.id }], 'assignee-role-named-twice'],
+    ["another tenant's role", () => [{ id: pool.id }, { id: theirPool.id }], 'assignee-role-not-in-this-domain']
+  ])('an activity saved with %s is refused by name and nothing is written', async (_, roles, code) => {
+    const before = await db.getRepository(Activity).count()
+
+    await expect(
+      db.transaction((tx: any) => new ActivityMutation().createActivity({ name: `bad-${code}`, assigneeRoles: roles() }, as(manager, tx)))
+    ).rejects.toMatchObject({ code })
+
+    expect(await db.getRepository(Activity).count()).toBe(before)
+  })
+
+  it('a case issued with the same role twice is refused by name and nothing is written', async () => {
+    const before = await db.getRepository(ActivityInstance).count()
+
+    await expect(
+      db.transaction((tx: any) => issue({ activityId: activity.id, assignees: [], assigneeRoles: [pool, pool], threadsMin: 1 }, as(manager, tx)))
+    ).rejects.toMatchObject({ code: 'assignee-role-named-twice' })
+
+    expect(await db.getRepository(ActivityInstance).count()).toBe(before)
+  })
+})
+
+describe('a role among assignees', () => {
+  const issueAs = (user: any, input: any) => db.transaction((tx: any) => issue(input, as(user, tx)))
+
+  it('handed in when issuing, is refused by name and nothing is written', async () => {
+    const before = await db.getRepository(ActivityInstance).count()
+
+    await expect(
+      issueAs(manager, { activityId: activity.id, assignees: [{ type: 'Role', value: pool.id }] })
+    ).rejects.toMatchObject({ code: 'role-is-not-an-assignee', message: 'error.activity-instance a role is not an assignee' })
+
+    expect(await db.getRepository(ActivityInstance).count()).toBe(before)
+  })
+
+  it('saved on the activity before this, is refused when a case of it is issued', async () => {
+    const saved = await db
+      .getRepository(Activity)
+      .save({ domain: here, name: 'payroll', activityType: 'standard', startingType: 'issue', assignees: [{ type: 'Role', value: pool.id }] })
+
+    await expect(issueAs(manager, { activityId: saved.id })).rejects.toMatchObject({ code: 'role-is-not-an-assignee' })
+  })
+
+  const mutation = new ActivityMutation()
+  const role = () => [{ type: 'Role', value: pool.id }]
+
+  it.each([
+    ['created', (context: any) => mutation.createActivity({ name: 'with-role', assignees: role() }, context)],
+    ['updated', async (context: any) => mutation.updateActivity(activity.id, { assignees: role() }, context)],
+    ['saved in a grid', (context: any) => mutation.updateMultipleActivity([{ name: 'grid-role', cuFlag: '+', assignees: role() }], context)],
+    ['imported', (context: any) => mutation.importActivities([{ name: 'imported-role', assignees: role() }], context)]
+  ])('on an activity being %s, is refused by name and nothing is written', async (_, save) => {
+    const before = await db.getRepository(Activity).count()
+
+    await expect(db.transaction((tx: any) => save(as(manager, tx)))).rejects.toMatchObject({ code: 'role-is-not-an-assignee' })
+
+    expect(await db.getRepository(Activity).count()).toBe(before)
+    expect((await db.getRepository(Activity).findOneBy({ id: activity.id })).assignees).toBeFalsy()
+  })
+
+  it('an activity saved with people among its assignees stands', async () => {
+    const saved = await db.transaction((tx: any) =>
+      mutation.createActivity({ name: 'with-person', assignees: [{ type: 'Myself' }] }, as(manager, tx))
+    )
+
+    expect(saved.assignees).toEqual([{ type: 'Myself' }])
+  })
+
+  it('a person among assignees is issued as before', async () => {
+    const issued = await issueAs(manager, { activityId: activity.id, assignees: [{ type: 'Myself' }] })
+
+    expect((await threadsOf(issued)).map((thread: any) => [thread.state, thread.assigneeId])).toEqual([['assigned', manager.id]])
+  })
+
+  it('the pool named by assigneeRoles is issued as before', async () => {
+    const issued = await issueAs(manager, { activityId: activity.id, assignees: [], assigneeRoles: [pool], threadsMin: 1 })
+
+    expect((await threadsOf(issued)).map((thread: any) => thread.state)).toEqual(['unassigned'])
+    expect(await onTheListOf(member, [pool], issued)).toBe(1)
+  })
+})

package/tests/assignee-pool-history.test.ts

@@ -0,0 +1,81 @@
+import { join } from 'path'
+
+/**
+ * The history row of an activity or a case keeps the pool **as it was saved** (ADR-0091 decision 9).
+ *
+ * The pool is a join table, so history keeps its ids, copied by name off the saved object's RelationId.
+ * typeorm fills that in with the new pool once the join rows are written (measured 2026-10-20), so the copy
+ * is the pool after the save. Real entities and subscribers on sqlite.
+ */
+
+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 { ActivityHistory } = require(join(DIST, 'service', 'activity', 'activity-history.js'))
+const { ActivityHistoryEntitySubscriber } = require(join(DIST, 'service', 'activity', 'event-subscriber.js'))
+const { ActivityInstance } = require(join(DIST, 'service', 'activity-instance', 'activity-instance.js'))
+const { ActivityInstanceHistory } = require(join(DIST, 'service', 'activity-instance', 'activity-instance-history.js'))
+const { ActivityInstanceHistoryEntitySubscriber } = require(join(DIST, 'service', 'activity-instance', 'event-subscriber.js'))
+const { ActivityMutation } = require(join(DIST, 'service', 'activity', 'activity-mutation.js'))
+const { withPoolIds } = require(join(DIST, 'service', 'activity-instance', 'event-subscriber.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 finance: any
+let support: any
+
+beforeAll(async () => {
+  db = createSqliteTestDataSource([Activity, ActivityHistory, ActivityInstance, ActivityInstanceHistory], {
+    subscribers: [ActivityHistoryEntitySubscriber, ActivityInstanceHistoryEntitySubscriber]
+  })
+  await db.initialize()
+
+  here = await db.getRepository(Domain).save({ name: 'here', subdomain: 'here' })
+  manager = await db.getRepository(User).save({ name: 'm', email: 'm@example.com', password: 'x', domains: [here] })
+  finance = await db.getRepository(Role).save({ domain: here, name: 'finance' })
+  support = await db.getRepository(Role).save({ domain: here, name: 'support' })
+})
+
+afterAll(async () => db?.destroy())
+
+const as = (tx: any) => ({ state: { domain: here, user: manager, tx }, t: (key: string) => key }) as any
+const latest = async (entity: any, originalId: string) =>
+  (await db.getRepository(entity).find({ where: { originalId }, order: { version: 'DESC' } }))[0]
+
+it("an activity's history keeps the pool it was changed to, not the one before", async () => {
+  const mutation = new ActivityMutation()
+  const created = await db.transaction((tx: any) => mutation.createActivity({ name: 'pay', assigneeRoles: [{ id: finance.id }] }, as(tx)))
+
+  await db.transaction((tx: any) =>
+    mutation.updateActivity(created.id, { assigneeRoles: [{ id: finance.id }, { id: support.id }] }, as(tx))
+  )
+
+  expect([...(await latest(ActivityHistory, created.id)).assigneeRoleIds].sort()).toEqual([finance.id, support.id].sort())
+})
+
+it("a case's history keeps the pool it was saved with", async () => {
+  const saved = await db.getRepository(ActivityInstance).save({ domain: here, name: 'case', state: 'issued', assigneeRoles: [support] })
+
+  expect((await latest(ActivityInstanceHistory, saved.id)).assigneeRoleIds).toEqual([support.id])
+})
+
+/*
+ * What is published goes through withPoolIds - the subscription filter decides who hears of a case by the
+ * pool's ids on it (subscription-filters.ts). A row saved without its pool in hand still carries them.
+ */
+it('a case published without its pool in hand carries the pool read from the join table', async () => {
+  const saved = await db.getRepository(ActivityInstance).save({ domain: here, name: 'published', state: 'issued', assigneeRoles: [finance, support] })
+  const read = await db.getRepository(ActivityInstance).findOne({ where: { id: saved.id } })
+  delete read.assigneeRoleIds
+
+  expect([...(await withPoolIds(read, db.manager)).assigneeRoleIds].sort()).toEqual([finance.id, support.id].sort())
+})
+
+it('a case published with its pool in hand carries those ids - the new pool, not a read before', async () => {
+  const published = await withPoolIds({ id: 'x', assigneeRoleIds: ['old'], assigneeRoles: [{ id: 'new' }] } as any, db.manager)
+
+  expect(published.assigneeRoleIds).toEqual(['new'])
+})

package/tests/may-read-case.test.ts

@@ -128,7 +128,8 @@ describe('one instance by id', () => {
       id: 'i-1',
       domainId: 'd-here',
       creatorId: 'u-operator',
-      assigneeRoleId: 'r-waiting'
+      /* The reader holds only the second role of the pool. */
+      assigneeRoleIds: ['r-other', 'r-waiting']
     })
     mockRows.set('ActivityThread:*', [{ id: 't-1', assigneeId: 'u-worker' }])
   })
@@ -151,7 +152,7 @@ describe('one instance by id', () => {
   })
 
   it('the waiting or supervisory role counts only when held in this domain', async () => {
-    mockRows.set('ActivityInstance:i-1', { id: 'i-1', domainId: 'd-here', assigneeRoleId: 'r-waiting', supervisoryRoleId: 'r-super' })
+    mockRows.set('ActivityInstance:i-1', { id: 'i-1', domainId: 'd-here', assigneeRoleIds: ['r-other', 'r-waiting'], supervisoryRoleId: 'r-super' })
 
     await expect(read(contextFor('u-elsewhere', ['r-waiting', 'r-super'], 'd-other'))).rejects.toThrow(
       'error.activity-case not a participant'

package/tests/org-member-domain.test.ts

@@ -52,20 +52,26 @@ const resolve = (item: any) =>
 
 it.each([
   ['Employee', 'employee'],
-  ['Department', 'department'],
-  ['Role', 'role']
+  ['Department', 'department']
 ])('an entry of type %s names the person of this domain', async (type, key) => {
   expect(await resolve({ type, value: mine[key].id })).toMatchObject({ id: mine.user.id })
 })
 
 it.each([
   ['Employee', 'employee'],
-  ['Department', 'department'],
-  ['Role', 'role']
+  ['Department', 'department']
 ])("an entry of type %s naming another tenant's is nobody here", async (type, key) => {
   expect(await resolve({ type, value: theirs[key].id })).toBeFalsy()
 })
 
+/* A role is not one person - it answered the role's first user (ruling 2026-10-20, assignee-input.ts). */
+it.each([
+  ['of this domain', () => mine],
+  ["of another tenant's", () => theirs]
+])('an entry of type Role %s is refused, never one person', async (_, whose) => {
+  await expect(resolve({ type: 'Role', value: whose().role.id })).rejects.toMatchObject({ code: 'role-is-not-an-assignee' })
+})
+
 describe('assign', () => {
   const assignTo = (instance: any, emails: string[]) =>
     db.transaction((tx: any) =>