openvisio-agent 0.19.12 → 0.20.0

package/scenarios/routing.scenarios.mjs

@@ -0,0 +1,348 @@
+import assert from 'node:assert/strict'
+import { assignmentRequest, assignmentStatusOnly, routeAssignments } from '../src/assignment-routing.mjs'
+import { dedicatedChannel, repliesAfterSource } from '../src/channel-routing.mjs'
+import { buildTaskCompletionReport, classifyConversationTarget, conversationAsksPendingTickets, conversationNeedsCode, mentionDedupeKeys, messageParentId, renderedAgentMessages, taskAgentId, taskBelongsToAgent, taskFromEvent } from '../src/events.mjs'
+import { createThreadContextResolver, ownThreadRoot } from '../src/thread-context.mjs'
+
+// Every axis below changes a supported transport or a decision input. Expected
+// outcomes describe workspace policy independently of production conditionals.
+export const scenarios = []
+const add = (id, category, description, run) => scenarios.push({ id: `routing-${id}`, category, description, run })
+const identity = { id: 7, identifier: 'alex', name: 'Alex Morgan' }
+const aliases = ['alex', 'alex morgan']
+const senders = [
+  ['human-email', { sender: { id: 7, email: 'alex@example.test' } }, false],
+  ['human-explicit-kind', { sender: { type: 'human', id: 7, identifier: 'alex' } }, false],
+  ['human-implicit', {}, false],
+  ['agent-expanded-camel', { senderAgent: { id: 9 } }, true],
+  ['agent-expanded-snake', { sender_agent: { id: 9 } }, true],
+  ['agent-flat-id', { agent_id: 9 }, true],
+  ['agent-sender-kind', { sender: { type: 'agent', identifier: 'atlas' } }, true],
+  ['agent-member-kind', { member: { type: 'bot', id: 9 } }, true],
+  ['agent-nested-principal', { sender: { agent: { id: 9, identifier: 'atlas' } } }, true],
+]
+const recipientCases = [
+  ['direct-request', '@Alex please fix the component.', 'handle'],
+  ['full-name-request', '@Alex Morgan please review the PR.', 'handle'],
+  ['case-insensitive', '@ALEX please check this.', 'handle'],
+  ['mention-punctuation', '(@Alex), can you check?', 'handle'],
+  ['unmentioned-follow-up', 'The build failed, please fix it.', 'follow-up'],
+  ['unmentioned-thanks', 'Thanks for the update.', 'follow-up'],
+  ['different-recipient', '@Atlas please fix this.', 'ignore'],
+  ['different-full-name', '@Atlas Smith please fix this.', 'ignore'],
+  ['explicit-stop', '@Alex stop working on this.', 'stand_down'],
+  ['explicit-do-not-start', "@Alex don't start this ticket.", 'stand_down'],
+  ['explicit-do-not-fix', '@Alex do not fix this.', 'stand_down'],
+  ['limited-no-deploy', "@Alex fix the component; don't deploy it.", 'handle'],
+  ['unmentioned-stop', 'Stop working on this.', 'stop-follow-up'],
+  ['later-agent-handoff', '@Alex thanks. @Atlas please fix the build.', 'ignore'],
+  ['shared-request', '@Alex and @Atlas please review this.', 'handle'],
+  ['explicit-shared-request', '@Alex and @Atlas can you both fix this?', 'handle'],
+  ['delegation-through-self', '@Alex ask @Atlas to review this.', 'handle'],
+  ['mention-in-email', 'Please send the update to contact@alex.', 'follow-up'],
+  ['email-to-other-person', 'Please use daniel@atlas.example for contact.', 'follow-up'],
+  ['longer-handle', '@Alexandra please review.', 'ignore'],
+  ['dotted-different-handle', '@Alex.morgan please review.', 'ignore'],
+  ['empty-event', '  ', 'ignore'],
+  ['reference-other-agent', "@Alex compare @Atlas's branch with yours?", 'handle'],
+]
+for (const [caseId, content, policy] of recipientCases) {
+  for (const [senderId, sender, agent] of senders) {
+    for (const owned of [false, true]) {
+      const expected = policy === 'follow-up' ? (!agent && owned ? 'handle' : 'ignore')
+        : policy === 'stop-follow-up' ? (!agent && owned ? 'stand_down' : 'ignore') : policy
+      add(`recipient-${caseId}-${senderId}-${owned ? 'owned' : 'unowned'}`, 'recipient', `${caseId}: ${senderId} in ${owned ? 'an owned' : 'an unowned'} thread must ${expected}.`, () => {
+        assert.equal(classifyConversationTarget({ id: 101, parent_id: 100, content, ...sender }, aliases, { threadOwned: owned }).action, expected)
+      })
+    }
+  }
+}
+for (const [caseId, content, policy] of [
+  ['list-with-no-start', '@Alex just list my pending tickets, do not start work.', 'handle'],
+  ['status-with-no-fix', '@Alex status only: show the ticket, do not fix it.', 'handle'],
+  ['stop-active-and-list', '@Alex stop working on this and just list my pending tickets.', 'stand_down'],
+  ['do-not-continue-and-list', '@Alex do not continue; just list my pending tickets.', 'stand_down'],
+  ['cancel-and-list', '@Alex cancel this; just list my pending tickets.', 'stand_down'],
+  ['untagged-list-with-no-start', 'Just list my pending tickets, do not start work.', 'follow-up'],
+]) for (const owned of [false, true]) {
+  add(`readonly-recipient-${caseId}-${owned ? 'owned' : 'unowned'}`, 'recipient', `${caseId} answers explicit inventory requests while preserving active-work cancellation precedence.`, () => {
+    const expected = policy === 'follow-up' ? (owned ? 'handle' : 'ignore') : policy
+    assert.equal(classifyConversationTarget({ content }, aliases, { threadOwned: owned }).action, expected)
+    assert.equal(assignmentStatusOnly(content), true)
+    assert.equal(assignmentRequest(content), null)
+    assert.equal(conversationNeedsCode(content), false)
+  })
+}
+
+const rootContent = 'Finished OPEN-77. PR: https://github.com/org/repo/pull/62.'
+const root = { id: 100, content: rootContent, sender_agent: { id: 7, identifier: 'alex', name: 'Alex Morgan' } }
+const threadEnvelopes = [
+  ['direct', (row) => row], ['messages', (row) => ({ messages: [row] })],
+  ['message-and-replies', (row) => ({ message: row, replies: [] })],
+  ['data-message', (row) => ({ data: { message: row } })],
+  ['result-items', (row) => ({ result: { items: [row] } })],
+  ['thread-root', (row) => ({ thread: { root: row } })],
+  ['array-root', (row) => [row]], ['data-messages', (row) => ({ data: { messages: [row] } })],
+]
+const authors = [
+  ['exact-identity', { sender_agent: { id: 7, identifier: 'alex' } }, true],
+  ['string-id', { senderAgent: { id: '7', identifier: 'alex' } }, true],
+  ['identifier-only', { agent: { identifier: 'alex' } }, true],
+  ['flat-id', { agent_id: 7 }, true],
+  ['member-envelope', { member: { type: 'agent', id: 7, identifier: 'alex' } }, true],
+  ['conflicting-id-same-identifier', { agent: { id: 8, identifier: 'alex', name: 'Alex Morgan' } }, false],
+  ['conflicting-identifier-same-name', { agent: { identifier: 'atlas', name: 'Alex Morgan' } }, false],
+  ['human-same-id', { sender: { id: 7, name: 'Alex Morgan', email: 'alex@example.test' } }, false],
+  ['explicit-human-identifier', { sender: { type: 'user', id: 7, identifier: 'alex' } }, false],
+  ['other-agent', { sender_agent: { id: 8, identifier: 'atlas' } }, false],
+]
+for (const [envelopeId, wrap] of threadEnvelopes) for (const [authorId, sender, self] of authors) {
+  add(`root-${envelopeId}-${authorId}`, 'thread-ownership', `${envelopeId} root authored by ${authorId} ${self ? 'establishes' : 'does not establish'} ownership.`, () => {
+    const value = wrap({ id: 100, content: rootContent, ...sender })
+    assert.equal(ownThreadRoot(value, 100, identity)?.content ?? null, self ? rootContent : null)
+    assert.equal(renderedAgentMessages(value, identity).length, self ? 1 : 0)
+  })
+}
+for (const field of ['parent_id', 'parentId', 'thread_id', 'threadId', 'reply_to', 'replyTo']) {
+  add(`non-root-${field}`, 'thread-ownership', `An agent reply carrying ${field} cannot masquerade as a root.`, () => {
+    assert.equal(ownThreadRoot({ ...root, [field]: 90 }, 100, identity), null)
+  })
+}
+for (const field of ['parent_id', 'parentId', 'thread_id', 'threadId', 'reply_to', 'replyTo']) {
+  for (const [shape, value] of [['scalar', 90], ['association-id', { id: 90 }], ['association-message-id', { message_id: 90 }]]) {
+    add(`parent-alias-${field}-${shape}`, 'thread-ownership', `${field}/${shape} retains the same thread identity in ownership and replay deduplication.`, () => {
+      const row = { ...root, [field]: value }
+      assert.equal(messageParentId(row), 90)
+      assert.equal(ownThreadRoot(row, 100, identity), null)
+      assert.equal(mentionDedupeKeys(row, 2).signatureKey, `sig:2|90|${rootContent}`)
+    })
+  }
+}
+for (const [label, value] of [['unknown-object', { unknown: 90 }], ['array', [90]], ['boolean', true], ['empty', ''], ['not-finite', NaN], ['negative-string', '-1'], ['zero-string', '0'], ['padded-zero', '00'], ['non-numeric-string', 'NaN']]) {
+  add(`parent-invalid-${label}`, 'thread-ownership', `${label} parent transport cannot become a malformed API thread ID.`, () => {
+    assert.equal(messageParentId({ parent_id: value }), null)
+    assert.equal(messageParentId({ parent_id: value, thread_id: 90 }), 90)
+  })
+}
+for (const field of ['message_id', 'messageId']) add(`root-canonical-message-id-${field}`, 'thread-ownership', `${field} wins over an unrelated transport envelope id.`, () => {
+  const row = { ...root, id: 'event-envelope', [field]: 100 }
+  assert.equal(ownThreadRoot(row, 100, identity)?.content, rootContent)
+  assert.equal(mentionDedupeKeys(row, 2).idKey, 'id:100')
+})
+
+const channelCases = [
+  ['exact-name', [{ id: 1, name: 'alex' }], { aliases: ['Alex'] }, 1],
+  ['prefixed-name', [{ id: 1, name: 'agent-alex' }], { aliases: ['Alex'] }, 1],
+  ['suffixed-name', [{ id: 1, name: 'alex-agent' }], { aliases: ['Alex'] }, 1],
+  ['full-name-normalized', [{ id: 1, name: '#Alex Morgan' }], { aliases: ['Alex Morgan'] }, 1],
+  ['numeric-owner', [{ id: 1, name: 'private', agent_id: 7 }], identity, 1],
+  ['camel-owner', [{ id: 1, name: 'private', agentId: 7 }], identity, 1],
+  ['identifier-owner', [{ id: 1, name: 'private', agent_identifier: 'alex' }], identity, 1],
+  ['camel-identifier-owner', [{ id: 1, name: 'private', agentIdentifier: 'alex' }], identity, 1],
+  ['explicit-config', [{ id: 1, name: 'configured' }], { channelId: 1 }, 1],
+  ['missing-config', [{ id: 1, name: 'alex' }], { ...identity, channelId: 2 }, null],
+  ['invalid-config-boolean', [{ id: 1, name: 'alex' }], { ...identity, channelId: true }, null],
+  ['invalid-config-zero', [{ id: 1, name: 'alex' }], { ...identity, channelId: 0 }, null],
+  ['invalid-config-negative', [{ id: 1, name: 'alex' }], { ...identity, channelId: -1 }, null],
+  ['ambiguous-name', [{ id: 1, name: 'alex' }, { id: 2, name: 'agent-alex' }], identity, null],
+  ['ambiguous-owner', [{ id: 1, agent_id: 7 }, { id: 2, agent_id: 7 }], identity, null],
+  ['other-owner-same-name', [{ id: 1, name: 'alex', agent_id: 8 }], identity, null],
+  ['other-owner-same-identifier', [{ id: 1, name: 'alex', agent_id: 8, agent_identifier: 'alex' }], identity, null],
+  ['other-identifier-same-name', [{ id: 1, name: 'alex', agent_identifier: 'atlas' }], identity, null],
+  ['general-not-fallback', [{ id: 1, name: 'general' }], identity, null],
+  ['team-not-fallback', [{ id: 1, name: 'team' }], identity, null],
+  ['no-channels', [], identity, null],
+  ['invalid-channel-list', null, identity, null],
+  ['boolean-channel-id', [{ id: true, name: 'alex' }], identity, null],
+  ['unsafe-channel-id', [{ id: Number.MAX_SAFE_INTEGER + 1, name: 'alex' }], identity, null],
+]
+for (const [id, channels, options, expected] of channelCases) add(`channel-${id}`, 'dedicated-channel', `Dedicated channel selection: ${id}.`, () => {
+  assert.equal(dedicatedChannel(channels, options)?.id ?? null, expected)
+})
+
+const codeIntents = [
+  ['direct-fix', 'Please fix the component.', false, true],
+  ['stop-button', 'Implement a stop button in the component.', false, true],
+  ['cancel-button', 'Fix the cancel button in the component.', false, true],
+  ['negative-fix', 'Do not fix the component.', false, false],
+  ['fix-with-no-deploy', "Fix the component; don't deploy it.", false, true],
+  ['fix-with-inline-no-deploy', "Fix the component and don't deploy it.", false, true],
+  ['negative-with-alternative', 'Do not deploy, but fix the component.', false, true],
+  ['build-contextual', 'The build failed so run build and fix the issue.', true, true],
+  ['build-without-context', 'The build failed so run build and fix the issue.', false, false],
+  ['rerun-tests-contextual', 'Run the tests again.', true, true],
+  ['thanks-contextual', 'Thanks for fixing that.', true, false],
+  ['status-contextual', 'How is it going?', true, false],
+  ['standdown-contextual', 'Stop working on the repository.', true, false],
+  ['feature-description', 'This feature is about API documentation.', false, false],
+]
+for (const [id, text, context, expected] of codeIntents) add(`code-intent-${id}`, 'request-intent', `Coding lane intent: ${id}.`, () => {
+  assert.equal(conversationNeedsCode(text, { rootContent: context ? rootContent : '' }), expected)
+})
+
+const actions = ['Start', 'Resume', 'Continue', 'Implement', 'Handle', 'Work through']
+const assignmentTargets = [
+  ['one-slug', 'open-77', ['OPEN-77']], ['two-slugs', 'open-77 and core-4', ['OPEN-77', 'CORE-4']],
+  ['duplicate-slug', 'OPEN-77 and open-77', ['OPEN-77']], ['pending-tickets', 'my pending tickets', []],
+  ['assigned-tasks', 'your assigned tasks', []], ['backlog', 'the backlog', []],
+]
+for (const action of actions) for (const [targetId, target, slugs] of assignmentTargets) {
+  add(`assignment-intent-${action.toLowerCase().replaceAll(' ', '-')}-${targetId}`, 'assignment-intent', `${action} ${target} resolves its explicitly requested scope.`, () => {
+    assert.deepEqual(assignmentRequest(`${action} ${target}`), { slugs })
+  })
+}
+for (const prefix of ['Do not start', "Don't implement", 'Just list', 'Only check']) for (const [targetId, target] of assignmentTargets) {
+  add(`assignment-readonly-${prefix.toLowerCase().replaceAll(' ', '-').replaceAll("'", '')}-${targetId}`, 'assignment-intent', `${prefix} ${target} must not dispatch coding.`, () => {
+    assert.equal(assignmentRequest(`${prefix} ${target}`), null)
+    assert.equal(assignmentStatusOnly(`${prefix} ${target}`), true)
+  })
+}
+for (const term of ['stop', 'cancel']) add(`assignment-feature-${term}-button`, 'assignment-intent', `A ${term} button feature name is not a work cancellation.`, () => {
+  assert.deepEqual(assignmentRequest(`Implement the ${term} button for OPEN-77`), { slugs: ['OPEN-77'] })
+})
+for (const [id, text] of [
+  ['check-if', 'Can you check if you have pending tasks?'],
+  ['list-assigned', 'List the tickets I assigned you.'],
+  ['tell-assigned', 'Tell me which tasks I assigned you.'],
+  ['whether-assigned', 'Verify whether you have any assigned tickets.'],
+  ['pending-question', 'Do you have pending tickets?'],
+]) add(`assignment-query-${id}`, 'assignment-intent', `A ${id} inventory question uses watcher discovery and permits automatic pickup of existing actionable assignments.`, () => {
+  assert.equal(assignmentRequest(text), null)
+  assert.equal(conversationAsksPendingTickets(text), true)
+  assert.equal(assignmentStatusOnly(text), false)
+})
+add('completed-ticket-status-does-not-reopen', 'assignment-intent', 'A status question about one completed ticket does not request new work or trigger pending inventory discovery.', async () => {
+  const text = 'What is the status of completed ticket OPEN-77?'
+  assert.equal(assignmentRequest(text), null)
+  assert.equal(conversationAsksPendingTickets(text), false)
+  let dispatched = 0
+  await routeAssignments({ request: { slugs: ['OPEN-77'] }, loadTickets: async () => [{ id: 77, projectId: 1, slug: 'OPEN-77', status: 'Done' }], handleTask: async () => { dispatched++ } })
+  assert.equal(dispatched, 0)
+})
+
+const ticketStates = [
+  ['actionable', { status: 'In Progress' }, true],
+  ['review', { awaitingReview: true, status: 'Testing' }, false],
+  ['completed', { status: 'Done' }, false],
+]
+for (const first of ticketStates) for (const second of ticketStates) for (const third of ticketStates) {
+  for (const scope of ['all', 'one']) {
+    const states = [first, second, third]
+    add(`dispatch-${states.map(([name]) => name).join('-')}-${scope}`, 'assignment-dispatch', `${scope} scope across ${states.map(([name]) => name).join('/')} tickets dispatches only actionable work.`, async () => {
+      const tickets = states.map(([, state], i) => ({ id: 77 + i, projectId: i === 2 ? 2 : 1, slug: `OPEN-${77 + i}`, ...state }))
+      const calls = []
+      const count = await routeAssignments({ request: { slugs: scope === 'one' ? ['OPEN-77'] : [] }, loadTickets: async () => tickets, handleTask: async (event, payload) => calls.push([event, payload.task.id]) })
+      const expected = states.flatMap(([, , actionable], i) => actionable && (scope === 'all' || i === 0) ? [['task:assigned', 77 + i]] : [])
+      assert.deepEqual(calls, expected)
+      assert.equal(count, expected.length)
+    })
+  }
+}
+for (const slugField of ['slug', 'ticket_slug', 'ticketSlug']) add(`dispatch-normalized-${slugField}`, 'assignment-dispatch', `Explicit slug matching accepts lowercase ${slugField} transport fields.`, async () => {
+  const calls = []
+  await routeAssignments({ request: { slugs: ['OPEN-77'] }, loadTickets: async () => [{ id: 77, project_id: 1, [slugField]: 'open-77' }], handleTask: async (_, payload) => calls.push(payload.task) })
+  assert.deepEqual(calls, [{ id: 77, project_id: 1 }])
+})
+for (const mode of ['before-first', 'after-first', 'after-second']) add(`dispatch-cancel-${mode}`, 'assignment-dispatch', `Cancellation ${mode} prevents subsequent ticket dispatch.`, async () => {
+  const stopAt = { 'before-first': 0, 'after-first': 1, 'after-second': 2 }[mode]
+  let calls = 0
+  const count = await routeAssignments({ request: { slugs: [] }, loadTickets: async () => [1, 2, 3].map((id) => ({ id, projectId: 1 })), isCancelled: () => calls >= stopAt, handleTask: async () => { calls++ } })
+  assert.equal(count, stopAt)
+  assert.equal(calls, stopAt)
+})
+add('dispatch-deduplicates-list', 'assignment-dispatch', 'Duplicate rows during pagination cannot enqueue the same project ticket twice.', async () => {
+  let calls = 0
+  const ticket = { id: 77, projectId: 1, slug: 'OPEN-77' }
+  assert.equal(await routeAssignments({ request: { slugs: [] }, loadTickets: async () => [ticket, { ...ticket }], handleTask: async () => { calls++ } }), 1)
+  assert.equal(calls, 1)
+})
+for (const issue of ['missing-slug', 'ambiguous-slug', 'invalid-list']) add(`dispatch-reject-${issue}`, 'assignment-dispatch', `${issue} fails before any work side effect.`, async () => {
+  let calls = 0
+  const ticket = { id: 77, projectId: 1, slug: 'OPEN-77' }
+  await assert.rejects(routeAssignments({ request: { slugs: ['OPEN-77'] }, loadTickets: async () => issue === 'invalid-list' ? {} : issue === 'missing-slug' ? [] : [ticket, { ...ticket, projectId: 2 }], handleTask: async () => { calls++ } }))
+  assert.equal(calls, 0)
+})
+add('dispatch-reject-partial-invalid-list', 'assignment-dispatch', 'An invalid later assignment fails validation before an earlier assignment is dispatched.', async () => {
+  let calls = 0
+  await assert.rejects(routeAssignments({ request: { slugs: [] }, loadTickets: async () => [{ id: 77, projectId: 1 }, { id: 78 }], handleTask: async () => { calls++ } }), /missing/)
+  assert.equal(calls, 0)
+})
+
+const assignmentShapes = [
+  ['snake', (id, identifier) => ({ agent_id: id, agent_identifier: identifier })],
+  ['camel', (id, identifier) => ({ agentId: id, agentIdentifier: identifier })],
+  ['expanded', (id, identifier) => ({ agent: { id, identifier } })],
+  ['assigned-snake', (id, identifier) => ({ assigned_agent: { id, identifier } })],
+  ['assigned-camel', (id, identifier) => ({ assignedAgent: { id, identifier } })],
+]
+const identities = [
+  ['self-id', 7, 'alex', true], ['self-string-id', '7', 'alex', true],
+  ['other-id-same-identifier', 8, 'alex', false], ['self-id-other-identifier', 7, 'atlas', true],
+  ['identifier-fallback', null, 'alex', true], ['other-identifier', null, 'atlas', false],
+  ['unassigned', null, null, false],
+]
+for (const [shape, make] of assignmentShapes) for (const [state, id, identifier, expected] of identities) {
+  add(`assignment-owner-${shape}-${state}`, 'assignment-ownership', `${shape} assignment with ${state} uses stable ID precedence.`, () => {
+    const task = { id: 77, ...make(id, identifier) }
+    assert.equal(taskAgentId(task), id)
+    assert.equal(taskBelongsToAgent(task, identity), expected)
+  })
+}
+const taskEnvelopes = [
+  ['direct', (task) => task], ['task', (task) => ({ task })], ['data-task', (task) => ({ data: { task } })],
+  ['payload-task', (task) => ({ payload: { task } })], ['data', (task) => ({ data: task })], ['payload', (task) => ({ payload: task })],
+]
+for (const [envelope, wrap] of taskEnvelopes) for (const [shape, make] of assignmentShapes) {
+  add(`task-transport-${envelope}-${shape}`, 'task-transport', `${envelope}/${shape} event retains assignment identity through normalization.`, () => {
+    const task = { id: 77, ...make(7, 'alex') }
+    assert.deepEqual(taskFromEvent(wrap(task)), task)
+    assert.equal(taskBelongsToAgent(taskFromEvent(wrap(task)), identity), true)
+  })
+}
+
+for (const field of ['type_id', 'typeId', 'status_id', 'statusId']) for (const state of ['done', 'review', 'active', 'no-pr']) {
+  add(`report-${field}-${state}`, 'completion-report', `${field} numeric-only ${state} state requires an actual handoff and PR evidence.`, () => {
+    const report = buildTaskCompletionReport({ id: 77, slug: 'OPEN-77', title: 'Fix build', [field]: state === 'done' ? 9 : state === 'active' ? 3 : 8, description: state === 'no-pr' ? '' : rootContent }, { completedTypeIds: new Set([9]), reviewTypeIds: new Set([8]) })
+    assert.equal(!!report, state === 'done' || state === 'review')
+    if (report) assert.match(report.content, state === 'done' ? /moved it to completed/ : /moved it to review/)
+  })
+}
+
+for (const source of [100, '100', '90071992547409930']) {
+  add(`fresh-reply-${source}-${typeof source}`, 'reply-deduplication', `Only agent replies newer than source ${source} count as delivery.`, () => {
+    const id = BigInt(source)
+    const rows = [null, { id: String(id - 1n) }, { id: String(id) }, { id: String(id + 1n) }, { id: 'opaque' }]
+    assert.deepEqual(repliesAfterSource(rows, source), [{ id: String(id + 1n) }])
+  })
+}
+add('opaque-source-remains-deliverable', 'reply-deduplication', 'Opaque source IDs cannot be ordered and must not suppress a fresh answer.', () => {
+  assert.deepEqual(repliesAfterSource([{ id: 'a' }], 'b'), [])
+})
+
+for (const phase of ['cache-hit', 'coalesced-load', 'cancel-before', 'cancel-during', 'retry-after-failure', 'other-root', 'own-reply-not-root', 'channel-isolation']) {
+  add(`resolve-thread-${phase}`, 'thread-context-lifecycle', `Thread context resolver handles ${phase} without inventing ownership.`, async () => {
+    const store = new Map()
+    let loads = 0
+    let cancelled = phase === 'cancel-before'
+    let finish
+    if (phase === 'cache-hit') store.set('2:100', rootContent)
+    const resolve = createThreadContextResolver({
+      read: (channel, id) => store.get(`${channel}:${id}`), save: (channel, id, text) => store.set(`${channel}:${id}`, text), cancelled: () => cancelled, identity: () => identity,
+      load: async () => {
+        loads++
+        if (phase === 'retry-after-failure' && loads === 1) throw new Error('temporary read outage')
+        if (phase === 'cancel-during') return new Promise((done) => { finish = done })
+        return { message: phase === 'other-root' ? { ...root, sender_agent: { id: 8 } } : phase === 'own-reply-not-root' ? { ...root, parent_id: 90 } : root }
+      },
+    })
+    if (phase === 'retry-after-failure') await assert.rejects(resolve(2, 100), /temporary read outage/)
+    const first = resolve(2, 100)
+    if (phase === 'cancel-during') { await Promise.resolve(); cancelled = true; finish({ message: root }) }
+    const values = await Promise.all([first, resolve(2, 100)])
+    const owned = !['cancel-before', 'cancel-during', 'other-root', 'own-reply-not-root'].includes(phase)
+    assert.deepEqual(values, [owned ? rootContent : '', owned ? rootContent : ''])
+    assert.equal(loads, ['cache-hit', 'cancel-before'].includes(phase) ? 0 : phase === 'retry-after-failure' ? 2 : 1)
+    if (phase === 'channel-isolation') { assert.equal(await resolve(3, 100), rootContent); assert.equal(loads, 2) }
+    if (!owned) assert.equal(store.size, 0)
+  })
+}