LZH-YS1998
539 lines
15 KiB
TypeScript
539 lines
15 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import type { ChatMessage } from '../types/chat'
|
|
import type { Session } from '../types/kanban'
|
|
import { mapBackendSession, mergeSessionDetailHasMore } from './collabSync'
|
|
import { canonicalizeSessionExecutionIdentity } from './sessionIdentity'
|
|
import { deriveCompanyRuntimeDisplayStatus, getConversationHeaderSession, getConversationSessionView, getWorkItemChildSessions, getWorkItemRoleSessions, mergeConversationMessages, projectSessionConversation, selectCompanySummaryMessages } from './workItemSessions'
|
|
|
|
function makeSession(overrides: Partial<Session> & Pick<Session, 'taskId' | 'channelId' | 'title' | 'status' | 'columnId' | 'assigneeIds' | 'priority' | 'tags' | 'progressLog' | 'createdAt' | 'updatedAt' | 'messageCount'>): Session {
|
|
return {
|
|
projectId: 'test-project',
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
const parent = makeSession({
|
|
taskId: 'root-task',
|
|
channelId: 'session:root-task',
|
|
title: 'Root',
|
|
status: 'running',
|
|
columnId: 'in-progress',
|
|
assigneeIds: [],
|
|
priority: null,
|
|
tags: [],
|
|
progressLog: [],
|
|
createdAt: 1,
|
|
updatedAt: 10,
|
|
messageCount: 1,
|
|
mode: 'primary',
|
|
originTaskId: 'root-task',
|
|
})
|
|
|
|
const child = makeSession({
|
|
taskId: 'child-task',
|
|
channelId: 'session:child-task',
|
|
title: 'CEO Intake',
|
|
status: 'done',
|
|
columnId: 'done',
|
|
assigneeIds: ['ceo'],
|
|
priority: null,
|
|
tags: [],
|
|
progressLog: [],
|
|
createdAt: 2,
|
|
updatedAt: 11,
|
|
messageCount: 2,
|
|
mode: 'child',
|
|
parentSessionId: 'parent-session-id-that-has-not-arrived-yet',
|
|
originTaskId: 'root-task',
|
|
})
|
|
|
|
const matches = getWorkItemChildSessions(parent, [parent, child])
|
|
assert.equal(matches.length, 1)
|
|
assert.equal(matches[0]?.taskId, 'child-task')
|
|
|
|
const companyParent = makeSession({
|
|
taskId: 'company-root',
|
|
channelId: 'session:company-root',
|
|
sessionId: 'company-root-session',
|
|
title: 'Work-Item Runtime Root',
|
|
status: 'running',
|
|
columnId: 'in-progress',
|
|
assigneeIds: [],
|
|
priority: null,
|
|
tags: [],
|
|
progressLog: [],
|
|
createdAt: 1,
|
|
updatedAt: 10,
|
|
messageCount: 1,
|
|
mode: 'primary',
|
|
execMode: 'company',
|
|
originTaskId: 'company-root',
|
|
})
|
|
|
|
const companyChild = makeSession({
|
|
taskId: 'company-child',
|
|
channelId: 'session:company-child',
|
|
title: 'CTO Delegation',
|
|
status: 'running',
|
|
columnId: 'in-progress',
|
|
assigneeIds: ['cto'],
|
|
priority: null,
|
|
tags: [],
|
|
progressLog: [],
|
|
createdAt: 2,
|
|
updatedAt: 25,
|
|
messageCount: 4,
|
|
mode: 'child',
|
|
parentSessionId: 'company-root-session',
|
|
originTaskId: 'company-root',
|
|
})
|
|
|
|
const companyProjection = projectSessionConversation(companyParent, [companyChild])
|
|
assert.deepEqual(
|
|
companyProjection.timelineSessions.map((session) => session.taskId),
|
|
['company-root', 'company-child'],
|
|
)
|
|
assert.equal(companyProjection.displaySession?.taskId, 'company-root')
|
|
assert.equal(companyProjection.runtimeSession?.taskId, 'company-child')
|
|
assert.equal(companyProjection.projectedFromChild, false)
|
|
|
|
const idleChildWithNewerInboxTimestamp = makeSession({
|
|
...companyChild,
|
|
taskId: 'company-idle-child',
|
|
channelId: 'session:company-idle-child',
|
|
title: 'Idle Child Inbox Update',
|
|
updatedAt: 1_000_000,
|
|
messageCount: 0,
|
|
progressLog: [],
|
|
})
|
|
const stableCompanyProjection = projectSessionConversation(companyParent, [idleChildWithNewerInboxTimestamp])
|
|
assert.equal(stableCompanyProjection.runtimeSession?.taskId, 'company-root')
|
|
|
|
const companyHeaderView = getConversationHeaderSession(
|
|
{
|
|
...companyParent,
|
|
workItemRoleName: 'CEO',
|
|
employeeAssignment: {
|
|
name: 'Root Employee',
|
|
category: 'leadership',
|
|
},
|
|
},
|
|
{
|
|
...companyChild,
|
|
workItemRoleName: 'CTO',
|
|
contextTokens: 0,
|
|
contextWindow: 128000,
|
|
inputTokens: 11,
|
|
outputTokens: 22,
|
|
totalTokens: 33,
|
|
turnCostUsd: 0.001,
|
|
sessionCostUsd: 0.002,
|
|
selectedExecutionAgent: 'codex',
|
|
employeeAssignment: {
|
|
name: 'Child Employee',
|
|
category: 'engineering',
|
|
},
|
|
},
|
|
[companyParent, companyChild],
|
|
)
|
|
assert.equal(companyHeaderView?.taskId, 'company-root')
|
|
assert.equal(companyHeaderView?.workItemRoleName, 'CEO')
|
|
assert.equal(companyHeaderView?.employeeAssignment?.name, 'Root Employee')
|
|
|
|
const resultMessage = (id: string, channelId: string, content: string, metadata: ChatMessage['metadata'], sender = 'chao'): ChatMessage => ({
|
|
id,
|
|
channelId,
|
|
sender,
|
|
senderName: sender === 'system' ? 'Company Member' : 'Chao',
|
|
content,
|
|
timestamp: 1000 + id.length,
|
|
mentions: [],
|
|
metadata,
|
|
})
|
|
|
|
const finalBody = 'Final delivery is ready with a long enough body to be considered the same user-visible result across transcript mirrors and worker notifications.'
|
|
const mergedDeliveryMessages = mergeConversationMessages([
|
|
[
|
|
resultMessage(
|
|
'opc-top-level',
|
|
'session:company-root',
|
|
finalBody,
|
|
{ source: 'engine', transcript_kind: 'top_level_reply' },
|
|
'assistant',
|
|
),
|
|
],
|
|
[
|
|
resultMessage(
|
|
'parent-mirror',
|
|
'session:company-root',
|
|
`**Deliver final result to user: Chao Intake**: ${finalBody}`,
|
|
{ source: 'engine', transcript_kind: 'child_result' },
|
|
),
|
|
],
|
|
[
|
|
resultMessage(
|
|
'child-direct',
|
|
'session:company-child',
|
|
finalBody,
|
|
{ source: 'engine', transcript_kind: 'child_task_result' },
|
|
),
|
|
resultMessage(
|
|
'worker-note',
|
|
'session:company-child',
|
|
finalBody,
|
|
{ source: 'runtime_event', kind: 'worker_notification', notification_kind: 'task_complete' },
|
|
'system',
|
|
),
|
|
],
|
|
])
|
|
|
|
assert.equal(mergedDeliveryMessages.length, 1)
|
|
assert.equal(mergedDeliveryMessages[0]?.id, 'child-direct')
|
|
|
|
const earlierResult = {
|
|
...resultMessage(
|
|
'earlier-parent-result',
|
|
'session:company-root',
|
|
finalBody,
|
|
{ source: 'engine', transcript_kind: 'child_result' },
|
|
),
|
|
timestamp: 900,
|
|
}
|
|
const authoritativeResult = {
|
|
...resultMessage(
|
|
'later-authoritative-result',
|
|
'session:company-child',
|
|
finalBody,
|
|
{ source: 'engine', transcript_kind: 'child_task_result' },
|
|
),
|
|
timestamp: 1_100,
|
|
}
|
|
for (const groups of [
|
|
[[earlierResult], [authoritativeResult]],
|
|
[[authoritativeResult], [earlierResult]],
|
|
]) {
|
|
const result = mergeConversationMessages(groups)
|
|
assert.equal(result.length, 1)
|
|
assert.equal(result[0]?.id, 'later-authoritative-result')
|
|
assert.equal(result[0]?.timestamp, 900, 'result chronology must not depend on channel traversal order')
|
|
}
|
|
|
|
const pendingCheckpoint = {
|
|
...resultMessage(
|
|
'pending-checkpoint-surface',
|
|
'session:company-root',
|
|
'Approval required.',
|
|
{ checkpoint_id: 'shared-checkpoint', checkpoint_type: 'human_escalation', status: 'pending' },
|
|
'system',
|
|
),
|
|
timestamp: 1_200,
|
|
}
|
|
const resolvedCheckpoint = {
|
|
...resultMessage(
|
|
'resolved-checkpoint-surface',
|
|
'session:company-child',
|
|
'Approval required.',
|
|
{ checkpoint_id: 'shared-checkpoint', checkpoint_type: 'human_escalation', status: 'resolved' },
|
|
'system',
|
|
),
|
|
timestamp: 1_300,
|
|
}
|
|
const mergedCheckpoint = mergeConversationMessages([[pendingCheckpoint], [resolvedCheckpoint]])
|
|
assert.equal(mergedCheckpoint.length, 1)
|
|
assert.equal(mergedCheckpoint[0]?.id, 'pending-checkpoint-surface')
|
|
assert.equal(mergedCheckpoint[0]?.timestamp, 1_200)
|
|
assert.equal(mergedCheckpoint[0]?.metadata?.status, 'resolved')
|
|
|
|
const companySummaryMessages = selectCompanySummaryMessages([
|
|
resultMessage(
|
|
'parent-user',
|
|
'session:company-root',
|
|
'Please investigate the issue.',
|
|
{ source: 'ui' },
|
|
'user',
|
|
),
|
|
resultMessage(
|
|
'child-transient',
|
|
'session:company-child',
|
|
'A child draft or internal assistant turn must stay out of the parent transcript.',
|
|
{ source: 'runtime_event', transcript_kind: 'runtime_v2_assistant' },
|
|
'assistant',
|
|
),
|
|
resultMessage(
|
|
'canonical-role-result',
|
|
'session:company-child',
|
|
'The canonical role delivery remains visible in the company summary.',
|
|
{ source: 'engine', transcript_kind: 'company_role_result' },
|
|
'assistant',
|
|
),
|
|
resultMessage(
|
|
'summary-company-final',
|
|
'session:company-child',
|
|
'A summary-visible company final remains when no canonical role mirror exists.',
|
|
{ source: 'engine', kind: 'runtime_v2_company_assistant', detail_visibility: 'summary' },
|
|
'assistant',
|
|
),
|
|
{
|
|
...resultMessage(
|
|
'parent-full-only-terminal',
|
|
'session:company-root',
|
|
'A full-only parent surface must neither render nor suppress the committed child summary.',
|
|
{
|
|
source: 'engine',
|
|
transcript_kind: 'runtime_v2_assistant',
|
|
detail_visibility: 'full',
|
|
canonical_turn_id: 'shared-terminal-turn',
|
|
},
|
|
'assistant',
|
|
),
|
|
timestamp: 1400,
|
|
},
|
|
{
|
|
...resultMessage(
|
|
'summary-terminal-a',
|
|
'session:company-child',
|
|
'First authoritative terminal for one shared canonical turn.',
|
|
{
|
|
source: 'engine',
|
|
transcript_kind: 'runtime_v2_assistant',
|
|
detail_visibility: 'summary',
|
|
canonical_turn_id: 'shared-terminal-turn',
|
|
},
|
|
'assistant',
|
|
),
|
|
timestamp: 1200,
|
|
},
|
|
{
|
|
...resultMessage(
|
|
'summary-terminal-b',
|
|
'session:company-sibling',
|
|
'A second terminal surface with different content must not duplicate the turn.',
|
|
{
|
|
source: 'engine',
|
|
transcript_kind: 'runtime_v2_assistant',
|
|
detail_visibility: 'summary',
|
|
canonical_turn_id: 'shared-terminal-turn',
|
|
},
|
|
'assistant',
|
|
),
|
|
timestamp: 1300,
|
|
},
|
|
resultMessage(
|
|
'child-checkpoint',
|
|
'session:company-child',
|
|
'Approval is required.',
|
|
{ checkpoint_id: 'checkpoint-child', checkpoint_type: 'company_work_item_gate' },
|
|
'assistant',
|
|
),
|
|
resultMessage(
|
|
'child-checkpoint-response',
|
|
'session:company-child',
|
|
'Approved.',
|
|
{ response_to_checkpoint_id: 'checkpoint-child', ui_message_id: 'ui-checkpoint-response' },
|
|
'user',
|
|
),
|
|
], 'session:company-root')
|
|
assert.deepEqual(
|
|
companySummaryMessages.map(message => message.id).sort(),
|
|
[
|
|
'parent-user',
|
|
'canonical-role-result',
|
|
'summary-company-final',
|
|
'summary-terminal-b',
|
|
'child-checkpoint',
|
|
'child-checkpoint-response',
|
|
].sort(),
|
|
)
|
|
assert.equal(companyHeaderView?.status, 'running')
|
|
assert.equal(companyHeaderView?.contextTokens, 0)
|
|
assert.equal(companyHeaderView?.contextWindow, 128000)
|
|
assert.equal(companyHeaderView?.inputTokens, 11)
|
|
assert.equal(companyHeaderView?.outputTokens, 22)
|
|
assert.equal(companyHeaderView?.totalTokens, 33)
|
|
assert.equal(companyHeaderView?.turnCostUsd, 0.001)
|
|
assert.equal(companyHeaderView?.sessionCostUsd, 0.002)
|
|
assert.equal(companyHeaderView?.selectedExecutionAgent, 'codex')
|
|
|
|
const customOrgRoot = makeSession({
|
|
taskId: 'custom-root',
|
|
channelId: 'session:custom-root',
|
|
sessionId: 'custom-root-session',
|
|
title: 'Custom Work-Item Runtime Root',
|
|
status: 'running',
|
|
columnId: 'in-progress',
|
|
assigneeIds: ['chief_architect'],
|
|
priority: null,
|
|
tags: [],
|
|
progressLog: [],
|
|
createdAt: 1,
|
|
updatedAt: 30,
|
|
messageCount: 1,
|
|
mode: 'primary',
|
|
execMode: 'custom',
|
|
isCompanyRuntime: true,
|
|
originTaskId: 'custom-root',
|
|
workItemRoleId: 'chief_architect',
|
|
workItemRoleName: 'Chief Architect',
|
|
})
|
|
|
|
const customOrgChild = makeSession({
|
|
taskId: 'custom-child',
|
|
channelId: 'session:custom-child',
|
|
title: 'Research Lead Turn',
|
|
status: 'running',
|
|
columnId: 'in-progress',
|
|
assigneeIds: ['research_lead'],
|
|
priority: null,
|
|
tags: [],
|
|
progressLog: [],
|
|
createdAt: 2,
|
|
updatedAt: 31,
|
|
messageCount: 2,
|
|
mode: 'child',
|
|
parentSessionId: 'custom-root-session',
|
|
originTaskId: 'custom-root',
|
|
workItemRoleId: 'research_lead',
|
|
workItemRoleName: 'Research Lead',
|
|
})
|
|
|
|
assert.deepEqual(
|
|
getWorkItemChildSessions(customOrgRoot, [customOrgRoot, customOrgChild]).map((session) => session.taskId),
|
|
['custom-child'],
|
|
)
|
|
assert.deepEqual(
|
|
getWorkItemRoleSessions(customOrgRoot, [customOrgRoot, customOrgChild]).map((session) => session.workItemRoleName),
|
|
['Chief Architect', 'Research Lead'],
|
|
)
|
|
|
|
const mergedCustomView = getConversationSessionView(
|
|
{
|
|
...customOrgRoot,
|
|
status: 'failed',
|
|
roleWorkItems: {
|
|
chief_architect: {
|
|
roleKey: 'chief_architect',
|
|
roleId: 'chief_architect',
|
|
roleName: 'Chief Architect',
|
|
runtimeStatus: 'idle',
|
|
aggregatedStatus: 'active',
|
|
workItems: [],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
...customOrgChild,
|
|
runtimeControlState: 'running',
|
|
canStop: true,
|
|
},
|
|
[customOrgRoot, customOrgChild],
|
|
)
|
|
assert.equal(mergedCustomView?.runtimeControlState, 'running')
|
|
assert.equal(mergedCustomView?.canStop, true)
|
|
assert.equal(mergedCustomView?.roleWorkItems?.chief_architect.roleName, 'Chief Architect')
|
|
assert.equal(mergedCustomView?.status, 'running')
|
|
assert.equal(deriveCompanyRuntimeDisplayStatus(mergedCustomView), 'running')
|
|
|
|
const failedCustomView = getConversationSessionView(
|
|
{
|
|
...customOrgRoot,
|
|
status: 'failed',
|
|
roleWorkItems: {
|
|
chief_architect: {
|
|
roleKey: 'chief_architect',
|
|
roleId: 'chief_architect',
|
|
roleName: 'Chief Architect',
|
|
runtimeStatus: 'idle',
|
|
aggregatedStatus: 'failed',
|
|
workItems: [],
|
|
},
|
|
},
|
|
},
|
|
null,
|
|
[],
|
|
)
|
|
assert.equal(failedCustomView?.status, 'failed')
|
|
|
|
const runtimeRollupOverridesStaleActiveView = getConversationSessionView(
|
|
{
|
|
...customOrgRoot,
|
|
status: 'failed',
|
|
roleWorkItems: {
|
|
chief_architect: {
|
|
roleKey: 'chief_architect',
|
|
roleId: 'chief_architect',
|
|
roleName: 'Chief Architect',
|
|
runtimeStatus: 'idle',
|
|
aggregatedStatus: 'failed',
|
|
workItems: [],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
...customOrgRoot,
|
|
status: 'failed',
|
|
roleWorkItems: {
|
|
chief_architect: {
|
|
roleKey: 'chief_architect',
|
|
roleId: 'chief_architect',
|
|
roleName: 'Chief Architect',
|
|
runtimeStatus: 'tool_active',
|
|
aggregatedStatus: 'active',
|
|
workItems: [],
|
|
},
|
|
},
|
|
},
|
|
[],
|
|
)
|
|
assert.equal(runtimeRollupOverridesStaleActiveView?.status, 'running')
|
|
|
|
const companyIdentity = canonicalizeSessionExecutionIdentity({
|
|
taskId: 'company-stale-org',
|
|
execMode: 'company',
|
|
companyProfile: 'custom',
|
|
orgId: 'quantum_harbor',
|
|
})
|
|
assert.equal(companyIdentity.execMode, 'company')
|
|
assert.equal(companyIdentity.companyProfile, 'corporate')
|
|
assert.equal(companyIdentity.orgId, undefined)
|
|
|
|
const customIdentity = canonicalizeSessionExecutionIdentity({
|
|
taskId: 'custom-org',
|
|
execMode: 'org',
|
|
companyProfile: 'corporate',
|
|
orgId: 'quantum_harbor',
|
|
})
|
|
assert.equal(customIdentity.execMode, 'org')
|
|
assert.equal(customIdentity.companyProfile, 'custom')
|
|
assert.equal(customIdentity.orgId, 'quantum_harbor')
|
|
|
|
const mappedCompanySession = mapBackendSession({
|
|
task_id: 'mapped-company',
|
|
channel_id: 'session:mapped-company',
|
|
title: 'Mapped Company',
|
|
status: 'running',
|
|
column_id: 'in-progress',
|
|
assignee_ids: [],
|
|
tags: [],
|
|
created_at: 1,
|
|
updated_at: 2,
|
|
exec_mode: 'company',
|
|
company_profile: 'custom',
|
|
org_id: 'quantum_harbor',
|
|
})
|
|
assert.equal(mappedCompanySession.execMode, 'company')
|
|
assert.equal(mappedCompanySession.companyProfile, 'corporate')
|
|
assert.equal(mappedCompanySession.orgId, undefined)
|
|
|
|
assert.equal(
|
|
mergeSessionDetailHasMore(false, true, false),
|
|
false,
|
|
'a cursorless live refresh must not reopen an exhausted history boundary',
|
|
)
|
|
assert.equal(
|
|
mergeSessionDetailHasMore(false, true, true),
|
|
true,
|
|
'a real cursor page may advance the scoped history boundary',
|
|
)
|
|
|
|
console.log('workItemSessions origin-task linking checks passed')
|