Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -119,6 +119,7 @@ describe('restored subagent liveness sweep', () => {
try {
expect(paneStatus(server)).toEqual({ state: 'working', subagents: [WORKING_CHILD] })
const previous = server.getStatusSnapshotForPane(PANE)[0]
expect(previous?.restoredUnconfirmed).toBe(true)
const previousReceivedAt = previous?.receivedAt ?? 0
const reconciledAt = previousReceivedAt + 1
const now = vi.spyOn(Date, 'now').mockReturnValue(previousReceivedAt)
Expand All @@ -130,6 +131,8 @@ describe('restored subagent liveness sweep', () => {
receivedAt: reconciledAt,
stateStartedAt: reconciledAt
})
// Why: the reconciled `done` is process-probe-verified, so it must shed the hydrated-unconfirmed marker.
expect(server.getStatusSnapshotForPane(PANE)[0]?.restoredUnconfirmed).toBeUndefined()
now.mockRestore()
} finally {
server.stop()
Expand Down Expand Up @@ -163,7 +166,9 @@ describe('restored subagent liveness sweep', () => {
state: 'waiting',
subagents: undefined,
receivedAt: previous?.receivedAt,
stateStartedAt: previous?.stateStartedAt
stateStartedAt: previous?.stateStartedAt,
// Why: a still-nonterminal reconciled row remains unconfirmed — only hooks or a terminal fact confirm it.
restoredUnconfirmed: true
})
} finally {
server.stop()
Expand Down
288 changes: 288 additions & 0 deletions src/main/agent-hooks/server.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -7026,6 +7026,294 @@ describe('Last-status persistence', () => {
}
})

it('restores hydrated nonterminal statuses as unconfirmed until a live event lands', async () => {
const firstServer = new AgentHookServer()
await firstServer.start({ env: 'production', userDataPath })
firstServer.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
payload: { state: 'working', prompt: 'may finish offline', agentType: 'claude' }
},
'conn-1'
)
firstServer.ingestRemote(
{
paneKey: GOOD_PANE,
tabId: 'tab-good',
worktreeId: 'wt-1',
payload: { state: 'done', prompt: 'finished before restart', agentType: 'claude' }
},
'conn-1'
)
firstServer.flushStatusPersistSync()
firstServer.stop()

const server = new AgentHookServer()
await server.start({ env: 'production', userDataPath })
try {
const listener = vi.fn()
server.setListener(listener)
expect(listener).toHaveBeenCalledWith(
expect.objectContaining({ paneKey: PANE, restoredUnconfirmed: true })
)
const byPane = new Map(server.getStatusSnapshot().map((entry) => [entry.paneKey, entry]))
expect(byPane.get(PANE)).toMatchObject({ state: 'working', restoredUnconfirmed: true })
// Why: `done` is a terminal fact — no later transition can have been missed, so it restores confirmed.
expect(byPane.get(GOOD_PANE)?.restoredUnconfirmed).toBeUndefined()

server.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
payload: { state: 'done', prompt: 'confirmed live', agentType: 'codex' }
},
'conn-1'
)
const confirmed = server.getStatusSnapshot().find((entry) => entry.paneKey === PANE)
expect(confirmed).toMatchObject({
state: 'done',
prompt: 'confirmed live',
agentType: 'codex'
})
expect(confirmed?.restoredUnconfirmed).toBeUndefined()
} finally {
server.stop()
}
})

it('lets an identical live OSC observation confirm a hydrated row', async () => {
const payload = {
state: 'working' as const,
prompt: 'still running',
agentType: 'claude' as const
}
const firstServer = new AgentHookServer()
await firstServer.start({ env: 'production', userDataPath })
firstServer.ingestTerminalStatus({
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
connectionId: null,
payload
})
firstServer.flushStatusPersistSync()
firstServer.stop()

const server = new AgentHookServer()
await server.start({ env: 'production', userDataPath })
try {
const restored = server.getStatusSnapshot()[0]
if (!restored) {
throw new Error('expected hydrated status')
}
expect(restored?.restoredUnconfirmed).toBe(true)
vi.spyOn(Date, 'now').mockReturnValue(restored.receivedAt - 1_000)
server.ingestTerminalStatus({
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
connectionId: null,
payload
})
const confirmed = server.getStatusSnapshot()[0]
expect(confirmed?.restoredUnconfirmed).toBeUndefined()
expect(confirmed?.receivedAt).toBe(restored.receivedAt + 1)
} finally {
server.stop()
}
})

it('does not let a hydrated Claude permission suppress the first live working event', async () => {
const firstServer = new AgentHookServer()
await firstServer.start({ env: 'production', userDataPath })
firstServer.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
hookEventName: 'PermissionRequest',
payload: {
state: 'waiting',
prompt: 'review command',
agentType: 'claude',
toolName: 'Bash',
toolInput: 'dangerous command'
}
},
'conn-1'
)
firstServer.flushStatusPersistSync()
firstServer.stop()

const server = new AgentHookServer()
await server.start({ env: 'production', userDataPath })
try {
server.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
hookEventName: 'PreToolUse',
payload: {
state: 'working',
prompt: 'review command',
agentType: 'claude',
toolName: 'Read',
toolInput: 'package.json'
}
},
'conn-1'
)
expect(server.getStatusSnapshot()[0]).toMatchObject({
state: 'working',
toolName: 'Read'
})
expect(server.getStatusSnapshot()[0]?.restoredUnconfirmed).toBeUndefined()
} finally {
server.stop()
}
})

it('does not inherit a stale tool id from hydrated Claude progress', async () => {
const firstServer = new AgentHookServer()
await firstServer.start({ env: 'production', userDataPath })
firstServer.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
hookEventName: 'PreToolUse',
toolUseId: 'tool-old',
toolAgentType: 'main',
payload: {
state: 'working',
prompt: 'run tests',
agentType: 'claude',
toolName: 'Bash',
toolInput: 'pnpm test'
}
},
'conn-1'
)
firstServer.flushStatusPersistSync()
firstServer.stop()

const server = new AgentHookServer()
await server.start({ env: 'production', userDataPath })
try {
server.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
hookEventName: 'PermissionRequest',
toolAgentType: 'main',
payload: {
state: 'waiting',
prompt: 'run tests',
agentType: 'claude',
toolName: 'Bash',
toolInput: 'pnpm test'
}
},
'conn-1'
)
server.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
hookEventName: 'PostToolUse',
toolUseId: 'tool-new',
toolAgentType: 'main',
payload: {
state: 'working',
prompt: 'run tests',
agentType: 'claude',
toolName: 'Bash',
toolInput: 'pnpm test'
}
},
'conn-1'
)
expect(server.getStatusSnapshot()[0]).toMatchObject({ state: 'working' })
} finally {
server.stop()
}
})

it('never persists the unconfirmed flag and re-stamps it on every hydrate', async () => {
const firstServer = new AgentHookServer()
await firstServer.start({ env: 'production', userDataPath })
firstServer.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
payload: { state: 'working', prompt: 'still running', agentType: 'claude' }
},
'conn-1'
)
firstServer.flushStatusPersistSync()
firstServer.stop()

const secondServer = new AgentHookServer()
await secondServer.start({ env: 'production', userDataPath })
secondServer.flushStatusPersistSync()
secondServer.stop()
expect(readFileSync(lastStatusPath(), 'utf8')).not.toContain('restoredUnconfirmed')

const thirdServer = new AgentHookServer()
await thirdServer.start({ env: 'production', userDataPath })
try {
expect(thirdServer.getStatusSnapshot()).toEqual([
expect.objectContaining({ paneKey: PANE, state: 'working', restoredUnconfirmed: true })
])
} finally {
thirdServer.stop()
}
})

it('refuses interrupt inference on an unconfirmed hydrated row', async () => {
const firstServer = new AgentHookServer()
await firstServer.start({ env: 'production', userDataPath })
firstServer.ingestRemote(
{
paneKey: PANE,
tabId: 'tab-1',
worktreeId: 'wt-1',
payload: { state: 'working', prompt: 'long task', agentType: 'codex' }
},
'conn-1'
)
firstServer.flushStatusPersistSync()
firstServer.stop()

const server = new AgentHookServer()
await server.start({ env: 'production', userDataPath })
try {
const baseline = server.getStatusSnapshot()[0]
expect(baseline).toMatchObject({ paneKey: PANE, restoredUnconfirmed: true })
const applied = server.inferInterrupt({
paneKey: PANE,
baselineUpdatedAt: baseline.receivedAt,
baselineStateStartedAt: baseline.stateStartedAt,
baselinePrompt: 'long task',
baselineAgentType: 'codex',
intent: 'plain-escape'
})
// Why: synthesizing `done` onto a never-confirmed `working` would fabricate a transition from stale disk state.
expect(applied).toBe(false)
expect(server.getStatusSnapshot()[0]).toMatchObject({ state: 'working' })
expect(server.getStatusSnapshot()[0]?.interrupted).toBeUndefined()
} finally {
server.stop()
}
})

it('keeps SSH status ordering monotonic across hydration and clock rollback', async () => {
const now = 1_700_000_000_000
vi.spyOn(Date, 'now').mockReturnValue(now)
Expand Down
Loading