Files
orca/src/shared/claude-background-task-status.test.ts

446 lines
16 KiB
TypeScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { describe, expect, it } from 'vitest'
import {
clearAllListenerCaches,
clearPaneCacheState,
createHookListenerState,
movePaneCacheState,
type HookListenerState
} from './agent-hook-listener/listener-state'
import {
markClaudeLeadTurnInterrupted,
seedClaudeSubagentRosterFromSnapshots
} from './agent-hook-listener/providers/claude-roster-state'
import { normalizeHookPayload } from './agent-hook-listener/normalization/normalize-hook-payload'
import { makePaneKey } from './workspace-layout/stable-pane-id'
const SOURCE_PANE = makePaneKey('tab-source', '11111111-1111-4111-8111-111111111111')
const TARGET_PANE = makePaneKey('tab-target', '22222222-2222-4222-8222-222222222222')
const RUNNING_SHELL = {
id: 'b8rs2wmxg',
type: 'shell',
status: 'running',
description: 'Sleep for 15 seconds',
command: 'sleep 15'
}
function claudeEvent(state: HookListenerState, paneKey: string, payload: Record<string, unknown>) {
return normalizeHookPayload(state, 'claude', { paneKey, payload }, 'production')?.payload
}
describe('Claude background task status', () => {
// SDK local_* names share inventory classification; teammate tasks stay running permanently, so lifecycle events own their pane state (#8825).
it('drains the Claude 2.1.229 background-task completion sequence', () => {
const state = createHookListenerState()
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'UserPromptSubmit',
prompt: 'run a background sleep'
})
).toMatchObject({ state: 'working', workingMode: undefined })
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
).toMatchObject({ state: 'working', workingMode: 'monitoring' })
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'SubagentStop',
agent_id: 'a70fdf2986e38302b',
background_tasks: [RUNNING_SHELL]
})
).toMatchObject({ state: 'working', workingMode: 'monitoring' })
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'UserPromptSubmit',
prompt:
'<task-notification><task-id>b8rs2wmxg</task-id><status>completed</status></task-notification>'
})
).toMatchObject({ state: 'working', workingMode: undefined })
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [],
session_crons: []
})?.state
).toBe('done')
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(false)
})
// Completion notifications need turnCompletedAt while the pane remains working for monitoring; pin both predicates (STA-4119).
it('holds the finish of a lead that ends into a working subagent, unless the lead failed', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'UserPromptSubmit', prompt: 'delegate' })
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'SubagentStart', agent_id: 'child-1' })
const childWorking = claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [{ id: 'child-1', type: 'subagent', status: 'running' }]
})
expect(childWorking).toMatchObject({ state: 'working', workingMode: undefined })
expect(childWorking?.turnCompletedAt).toBeUndefined()
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'UserPromptSubmit', prompt: 'again' })
const failed = claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'StopFailure',
background_tasks: [{ id: 'child-1', type: 'subagent', status: 'running' }]
})
expect(failed).toMatchObject({ state: 'working', workingMode: undefined })
expect(typeof failed?.turnCompletedAt).toBe('number')
})
it('holds a coordinator waiting on workers in the background, even across a listener restart', () => {
const wait = {
id: 'wait-1',
type: 'shell',
status: 'running',
description: 'Wait for next worker message',
command:
'/usr/local/bin/orca orchestration check --wait --types worker_done --json 2>/dev/null'
}
const launched = createHookListenerState()
claudeEvent(launched, SOURCE_PANE, { hook_event_name: 'UserPromptSubmit', prompt: 'run' })
claudeEvent(launched, SOURCE_PANE, {
hook_event_name: 'PostToolUse',
tool_name: 'Bash',
tool_input: { command: wait.command, run_in_background: true },
tool_response: { backgroundTaskId: 'wait-1' }
})
// Only the dev server is still listed; the ended wait's notification is still owed.
const owed = claudeEvent(launched, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
expect(owed).toMatchObject({ state: 'working', workingMode: undefined })
expect(owed?.turnCompletedAt).toBeUndefined()
const restarted = createHookListenerState()
claudeEvent(restarted, SOURCE_PANE, { hook_event_name: 'UserPromptSubmit', prompt: 'run' })
const listed = claudeEvent(restarted, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [wait]
})
expect(listed).toMatchObject({ state: 'working', workingMode: undefined })
expect(listed?.turnCompletedAt).toBeUndefined()
// Only listed, it may be a subagent's wait, whose result never reaches this agent.
expect(
claudeEvent(restarted, SOURCE_PANE, { hook_event_name: 'Stop', background_tasks: [] })?.state
).toBe('done')
})
it('does not stamp a wake-up turn that ends with only a monitor that will wake it again', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'UserPromptSubmit', prompt: 'watch' })
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'PostToolUse',
tool_name: 'Bash',
tool_input: { command: 'sleep 15', run_in_background: true },
tool_response: { backgroundTaskId: RUNNING_SHELL.id }
})
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop', background_tasks: [RUNNING_SHELL] })
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'UserPromptSubmit',
prompt: `<task-notification>\n<task-id>${RUNNING_SHELL.id}</task-id>\n<event>tick</event>`
})
const wakeEnd = claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
expect(wakeEnd).toMatchObject({ state: 'working', workingMode: 'monitoring' })
expect(wakeEnd?.turnCompletedAt).toBeUndefined()
})
it('keeps pending task state when pane authority moves', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
movePaneCacheState(state, SOURCE_PANE, TARGET_PANE)
expect(
claudeEvent(state, TARGET_PANE, {
hook_event_name: 'SubagentStop',
agent_id: 'a70fdf2986e38302b'
})?.state
).toBe('working')
})
it('keeps a shell the interrupted Stop still lists until an inventory omits it', () => {
const state = createHookListenerState()
const monitoring = {
state: 'working',
workingMode: 'monitoring',
mainAgent: { state: 'done', outcome: 'cancellation' }
}
const interrupted = claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
is_interrupt: true,
background_tasks: [RUNNING_SHELL]
})
expect(interrupted).toMatchObject(monitoring)
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'SubagentStop',
agent_id: 'a70fdf2986e38302b',
background_tasks: [RUNNING_SHELL]
})
).toMatchObject(monitoring)
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
).toMatchObject(monitoring)
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'SubagentStop',
agent_id: 'a8ab60ba5d4410c47',
background_tasks: [RUNNING_SHELL]
})
).toMatchObject(monitoring)
// Inventory omission settles the shell; interrupted restates the carried lead verdict for old readers.
expect(
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop', background_tasks: [] })
).toMatchObject({ state: 'done', interrupted: true, mainAgent: { outcome: 'cancellation' } })
})
it('drains a reported cron inventory mid-turn, not only at a turn boundary', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
session_crons: [{ id: 'cron-1' }]
})
expect(state.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(true)
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'PostToolUse',
session_crons: []
})?.state
).toBe('working')
expect(state.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(false)
// A mid-turn drain must survive the boundary or a missing next inventory leaves stale cron work pinned.
expect(claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop' })?.state).toBe('done')
})
it('only infers an omitted cron inventory is drained from modern lead Stop payloads', () => {
const createCronState = (): HookListenerState => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
session_crons: [{ id: 'cron-1' }]
})
return state
}
const midTurnState = createCronState()
claudeEvent(midTurnState, SOURCE_PANE, {
hook_event_name: 'UserPromptSubmit',
prompt: 'continue',
background_tasks: []
})
expect(midTurnState.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(true)
const legacyStopState = createCronState()
expect(claudeEvent(legacyStopState, SOURCE_PANE, { hook_event_name: 'Stop' })?.state).toBe(
'working'
)
expect(legacyStopState.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(true)
})
it('drops interrupted state on a mid-turn lead event with no prompt submit', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop', is_interrupt: true })
// Why: a resumed turn can start at a tool event; the next Stop must not inherit the old interrupt and discard live work.
expect(claudeEvent(state, SOURCE_PANE, { hook_event_name: 'PreToolUse' })?.state).toBe(
'working'
)
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
).toMatchObject({ state: 'working', interrupted: undefined })
})
it('ignores child-attributed inventories for lead-owned background work', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
agent_id: 'child-1',
background_tasks: [RUNNING_SHELL],
session_crons: [{ id: 'cron-1' }]
})
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(false)
expect(state.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(false)
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL],
session_crons: [{ id: 'cron-1' }]
})
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
agent_id: 'child-1',
background_tasks: [],
session_crons: []
})
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(true)
expect(state.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(true)
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [],
session_crons: []
})
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(false)
expect(state.claudeActiveSessionCronPaneKeys.has(SOURCE_PANE)).toBe(false)
})
it('retains live child rows when an agent inventory is partial or has a future status', () => {
for (const backgroundTask of [
{ id: 'child-1', type: 'subagent', status: 'in_progress' },
{ id: 'child-1', type: 'subagent' },
{ task_id: 'child-1', type: 'subagent', status: 'running' }
]) {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'SubagentStart',
agent_id: 'child-1'
})
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [backgroundTask]
})
).toMatchObject({
state: 'working',
subagents: [expect.objectContaining({ id: 'child-1', state: 'working' })]
})
}
})
it('does not mint working from an unconfirmed child-attributed Stop', () => {
const state = createHookListenerState()
seedClaudeSubagentRosterFromSnapshots(state, SOURCE_PANE, [
{ id: 'restored-child', state: 'working', startedAt: 100 }
])
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
agent_id: 'unknown-child',
background_tasks: []
})
).toBeUndefined()
})
it('ignores TeammateIdle inventories for lead-owned background work', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'TeammateIdle',
teammate_name: 'reviewer',
background_tasks: []
})?.state
).toBe('working')
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(true)
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop', background_tasks: [] })
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'TeammateIdle',
teammate_name: 'reviewer',
background_tasks: [RUNNING_SHELL]
})
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(false)
})
it('shows a child permission wait after the lead turn is interrupted', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'SubagentStart',
agent_id: 'child-1'
})
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop', is_interrupt: true })
expect(
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'PermissionRequest',
agent_id: 'child-1',
tool_name: 'Bash',
tool_input: { command: 'git status' }
})
).toMatchObject({ state: 'waiting', toolName: 'Bash' })
})
it('preserves authoritative work across partial inventories and clears it on teardown', () => {
const state = createHookListenerState()
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
expect(claudeEvent(state, SOURCE_PANE, { hook_event_name: 'Stop' })).toMatchObject({
state: 'working',
workingMode: 'monitoring'
})
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(true)
clearPaneCacheState(state, SOURCE_PANE)
expect(state.claudeRunningNonAgentTaskPaneKeys.size).toBe(0)
claudeEvent(state, TARGET_PANE, {
hook_event_name: 'Stop',
background_tasks: [RUNNING_SHELL]
})
clearAllListenerCaches(state)
expect(state.claudeRunningNonAgentTaskPaneKeys.size).toBe(0)
})
it('keeps a live shell as a confirmed done-gate for child lifecycle events after a cancel', () => {
const state = createHookListenerState()
// A truncated inventory adds a shell without retiring the restored child seed.
seedClaudeSubagentRosterFromSnapshots(state, SOURCE_PANE, [
{ id: 'restored-1', state: 'working', startedAt: 1 }
])
claudeEvent(state, SOURCE_PANE, { hook_event_name: 'UserPromptSubmit', prompt: 'resume' })
claudeEvent(state, SOURCE_PANE, {
hook_event_name: 'Stop',
background_tasks: [{ id: 'shell-x', status: 'running' }]
})
expect(state.claudeRunningNonAgentTaskPaneKeys.has(SOURCE_PANE)).toBe(true)
markClaudeLeadTurnInterrupted(state, SOURCE_PANE)
// A live shell confirms inventory regardless of lead verdict; a sibling’s end cannot make it restored-only.
const ended = normalizeHookPayload(
state,
'claude',
{ paneKey: SOURCE_PANE, payload: { hook_event_name: 'SubagentStop', agent_id: 'other' } },
'production'
)
expect(ended?.restoredUnconfirmed).toBeUndefined()
expect(state.claudeUnconfirmedRestoredStatusPaneKeys.has(SOURCE_PANE)).toBe(false)
expect(ended?.payload).toMatchObject({
state: 'working',
mainAgent: { state: 'done', outcome: 'cancellation' }
})
})
})