mirror of
https://github.com/stablyai/orca.git
synced 2026-11-19 04:23:57 +00:00
test: remove low-value ports and AI Vault tests (#38493)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
This commit is contained in:
@@ -7650,7 +7650,6 @@
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/scope/ai-vault-session-projects.test.ts": 117,
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/scanning/ai-vault-session-publication-gate.test.ts": 196,
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/scanning/ai-vault-session-refresh.test.ts": 2034,
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/session-actions/ai-vault-session-resume-in-chat-launch.test.ts": 1260,
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/session-actions/ai-vault-session-resume-in-chat-workspace.test.ts": 746,
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/session-actions/ai-vault-session-resume.test.ts": 1753,
|
||||
"src/renderer/src/components/right-sidebar/ai-vault/session-list/ai-vault-session-worktree-map.test.tsx": 2000,
|
||||
|
||||
@@ -1,32 +0,0 @@
|
||||
// @vitest-environment happy-dom
|
||||
import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
|
||||
import { afterEach, expect, it, vi } from 'vitest'
|
||||
import { AddToChatPointMenuHost } from './AddToChatMenu'
|
||||
import { openAddToChatMenuAt } from './add-to-chat-point-menu'
|
||||
|
||||
vi.mock('@/components/editor/review-note-delivery/ReviewNotesSendMenuContent', () => ({
|
||||
ReviewNotesSendMenuContent: () => <div role="menuitem">Chat A</div>
|
||||
}))
|
||||
|
||||
afterEach(cleanup)
|
||||
|
||||
// The menu opens from a hidden anchor; cancelling it must hand focus back to the selection's editor.
|
||||
it('returns focus to where the selection was when the menu is dismissed with Escape', async () => {
|
||||
render(
|
||||
<>
|
||||
<textarea aria-label="editor" />
|
||||
<AddToChatPointMenuHost />
|
||||
</>
|
||||
)
|
||||
const editor = screen.getByLabelText('editor')
|
||||
editor.focus()
|
||||
act(() =>
|
||||
openAddToChatMenuAt({ worktreeId: 'wt', quote: '> q', launchSource: 'native_chat', x: 1, y: 1 })
|
||||
)
|
||||
expect(screen.getByText('Chat A')).toBeTruthy()
|
||||
fireEvent.keyDown(document.activeElement ?? document.body, { key: 'Escape' })
|
||||
expect(screen.queryByText('Chat A')).toBeNull()
|
||||
// Radix hands focus back a task after the menu unmounts.
|
||||
await act(() => new Promise((resolve) => setTimeout(resolve, 0)))
|
||||
expect(document.activeElement).toBe(editor)
|
||||
})
|
||||
@@ -1,6 +1,6 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import type { Tab } from '../../../../shared/tab-types'
|
||||
import { addQuoteToAgent, workspaceChatTargetFor } from './native-chat-workspace-selection'
|
||||
import { workspaceChatTargetFor } from './native-chat-workspace-selection'
|
||||
|
||||
const sendMessageToAgent = vi.hoisted(() => vi.fn())
|
||||
vi.mock('@/lib/agent-message-send', () => ({ sendMessageToAgent }))
|
||||
@@ -75,17 +75,4 @@ describe('workspaceChatTargetFor', () => {
|
||||
})
|
||||
).toBeNull()
|
||||
})
|
||||
|
||||
// A plain terminal agent has no composer: it gets the notes send's paste, without the Enter.
|
||||
it('pastes into a plain terminal agent without submitting', async () => {
|
||||
sendMessageToAgent.mockResolvedValue({ status: 'sent' })
|
||||
const target = { kind: 'terminal' as const, tabId: 'term-plain', leafId: CHAT_LEAF }
|
||||
await expect(addQuoteToAgent('wt-1', target, '> quote')).resolves.toEqual({ status: 'sent' })
|
||||
expect(sendMessageToAgent).toHaveBeenCalledWith({
|
||||
worktreeId: 'wt-1',
|
||||
target,
|
||||
prompt: '> quote',
|
||||
submit: false
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
-309
@@ -1,309 +0,0 @@
|
||||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { StructuredAgentLaunchSettlement } from '@/lib/structured-agent-launch-settlement'
|
||||
import type { ExecutionHostId } from '../../../../../../shared/execution-host'
|
||||
import type { AiVaultSession } from '../../../../../../shared/ai-vault/contracts/ai-vault-types'
|
||||
|
||||
type BeginArgs = { beforeOpen?: (sessionId: string) => boolean | void }
|
||||
type Launch = {
|
||||
sessionId: string
|
||||
settlement: Promise<StructuredAgentLaunchSettlement>
|
||||
tab: { id: string }
|
||||
}
|
||||
|
||||
const mocks = vi.hoisted(() => {
|
||||
const state: { owner: ExecutionHostId | null } = { owner: 'local' }
|
||||
return {
|
||||
beginStructuredAgentSessionProvisionalLaunch: vi.fn<(args: BeginArgs) => Launch | null>(),
|
||||
prepareAiVaultSessionForResume: vi.fn<() => Promise<{ sessionId: string }>>(),
|
||||
activateAndRevealWorkspace: vi.fn<(workspaceId: string) => unknown>(),
|
||||
toastError: vi.fn<(message: string) => void>(),
|
||||
admitStructuredLaunchOnHost:
|
||||
vi.fn<(target: unknown, worktree: string, agent: string) => Promise<{ kind: string }>>(),
|
||||
...state,
|
||||
sleeping: false,
|
||||
navigationIndex: 0,
|
||||
activeWorktreeId: 'other-worktree'
|
||||
}
|
||||
})
|
||||
|
||||
vi.mock('@/lib/agent-session/structured-agent-session-provisional-tab', () => ({
|
||||
beginStructuredAgentSessionProvisionalLaunch: mocks.beginStructuredAgentSessionProvisionalLaunch,
|
||||
structuredLaunchOwner: (plan: { executionHostId?: ExecutionHostId }) => {
|
||||
const executionHostId = plan.executionHostId ?? mocks.owner
|
||||
return executionHostId
|
||||
? {
|
||||
executionHostId,
|
||||
target:
|
||||
executionHostId === 'local'
|
||||
? { kind: 'local' }
|
||||
: { kind: 'environment', environmentId: executionHostId.slice('runtime:'.length) }
|
||||
}
|
||||
: null
|
||||
}
|
||||
}))
|
||||
vi.mock('@/lib/agent-session/launch/structured-agent-session-host-admission', () => ({
|
||||
admitStructuredLaunchOnHost: mocks.admitStructuredLaunchOnHost
|
||||
}))
|
||||
vi.mock('@/lib/ai-vault-session-resume-preparation', () => ({
|
||||
prepareAiVaultSessionForResume: mocks.prepareAiVaultSessionForResume
|
||||
}))
|
||||
vi.mock('@/lib/worktree-activation', () => ({
|
||||
activateAndRevealWorkspace: mocks.activateAndRevealWorkspace
|
||||
}))
|
||||
vi.mock('sonner', () => ({ toast: { error: mocks.toastError } }))
|
||||
vi.mock('@/store/index', () => ({
|
||||
useAppStore: {
|
||||
getState: () => ({
|
||||
activeWorktreeId: mocks.activeWorktreeId,
|
||||
worktreeNavHistoryIndex: mocks.navigationIndex,
|
||||
sleepingAgentSessionsByPaneKey: mocks.sleeping ? { source: { worktreeId: 'worktree-1' } } : {}
|
||||
})
|
||||
}
|
||||
}))
|
||||
|
||||
import { resumeAiVaultSessionInNewChat } from './ai-vault-session-resume-in-chat-launch'
|
||||
|
||||
const session: AiVaultSession = {
|
||||
id: 'vault-1',
|
||||
executionHostId: 'local',
|
||||
agent: 'codex',
|
||||
sessionId: 'vault-1',
|
||||
title: 'Vault session',
|
||||
cwd: '/x',
|
||||
branch: null,
|
||||
model: null,
|
||||
filePath: '/x',
|
||||
codexHome: null,
|
||||
createdAt: null,
|
||||
updatedAt: null,
|
||||
modifiedAt: '2025-01-01T00:00:00.000Z',
|
||||
messageCount: 1,
|
||||
totalTokens: 1,
|
||||
previewMessages: [],
|
||||
queuedMessageCount: 0,
|
||||
subagentTranscriptCount: 0,
|
||||
resumeCommand: 'resume',
|
||||
subagent: null
|
||||
}
|
||||
|
||||
describe('resumeAiVaultSessionInNewChat', () => {
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks()
|
||||
mocks.owner = 'local'
|
||||
mocks.sleeping = false
|
||||
mocks.navigationIndex = 0
|
||||
mocks.activeWorktreeId = 'other-worktree'
|
||||
mocks.prepareAiVaultSessionForResume.mockResolvedValue({ sessionId: 'provider-1' })
|
||||
mocks.activateAndRevealWorkspace.mockReturnValue({ primaryTabId: null })
|
||||
mocks.beginStructuredAgentSessionProvisionalLaunch.mockImplementation((args) => {
|
||||
args.beforeOpen?.('session-1')
|
||||
return {
|
||||
sessionId: 'session-1',
|
||||
tab: { id: 'agent-session:session-1' },
|
||||
settlement: Promise.resolve({ kind: 'structured', sessionId: 'session-1' })
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
it('keeps the recording server when workspace selection changes during preparation', async () => {
|
||||
mocks.owner = 'runtime:server-1'
|
||||
let finish!: (value: { sessionId: string }) => void
|
||||
mocks.prepareAiVaultSessionForResume.mockReturnValue(
|
||||
new Promise((resolve) => {
|
||||
finish = resolve
|
||||
})
|
||||
)
|
||||
mocks.admitStructuredLaunchOnHost.mockResolvedValue({ kind: 'admitted' })
|
||||
const launched = resumeAiVaultSessionInNewChat(
|
||||
{ ...session, executionHostId: 'runtime:server-1' },
|
||||
'opencode2',
|
||||
'worktree-1',
|
||||
'resume-click'
|
||||
)
|
||||
mocks.owner = 'runtime:server-2'
|
||||
mocks.activeWorktreeId = 'worktree-1'
|
||||
finish({ sessionId: 'provider-1' })
|
||||
await launched
|
||||
expect(mocks.activateAndRevealWorkspace).toHaveBeenCalledWith('worktree-1', {
|
||||
executionHostId: 'runtime:server-1'
|
||||
})
|
||||
expect(mocks.admitStructuredLaunchOnHost).toHaveBeenCalledWith(
|
||||
{ kind: 'environment', environmentId: 'server-1' },
|
||||
'id:worktree-1',
|
||||
'opencode2'
|
||||
)
|
||||
expect(mocks.beginStructuredAgentSessionProvisionalLaunch).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
plan: expect.objectContaining({ executionHostId: 'runtime:server-1' })
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
it.each(['local', 'runtime:server-2', null] as const)(
|
||||
'refuses a recording-host mismatch before preparing history: %s',
|
||||
async (owner) => {
|
||||
mocks.owner = owner
|
||||
await resumeAiVaultSessionInNewChat(
|
||||
{ ...session, executionHostId: 'runtime:server-1' },
|
||||
'codex',
|
||||
'worktree-1',
|
||||
'resume-click'
|
||||
)
|
||||
expect(mocks.prepareAiVaultSessionForResume).not.toHaveBeenCalled()
|
||||
expect(mocks.beginStructuredAgentSessionProvisionalLaunch).not.toHaveBeenCalled()
|
||||
expect(mocks.toastError).toHaveBeenCalledOnce()
|
||||
}
|
||||
)
|
||||
|
||||
it.each(['ssh:relay', 'runtime:unresolved-owner'] as const)(
|
||||
'does not prepare a conversation from a non-runtime owner: %s',
|
||||
async (executionHostId) => {
|
||||
mocks.owner = executionHostId
|
||||
await resumeAiVaultSessionInNewChat(
|
||||
{ ...session, executionHostId },
|
||||
'codex',
|
||||
'worktree-1',
|
||||
'resume-click'
|
||||
)
|
||||
expect(mocks.prepareAiVaultSessionForResume).not.toHaveBeenCalled()
|
||||
expect(mocks.beginStructuredAgentSessionProvisionalLaunch).not.toHaveBeenCalled()
|
||||
}
|
||||
)
|
||||
|
||||
it.each([false, true])(
|
||||
'reveals the workspace and opens chat before provider settlement (aliases: %s)',
|
||||
async (aliases) => {
|
||||
const source = {
|
||||
...session,
|
||||
cwd: '/private/var/example',
|
||||
...(aliases ? { cwdAliases: ['/var/example'], sessionId: 'provider-1' } : {})
|
||||
}
|
||||
let settle!: (value: StructuredAgentLaunchSettlement) => void
|
||||
const settlement = new Promise<StructuredAgentLaunchSettlement>((resolve) => {
|
||||
settle = resolve
|
||||
})
|
||||
mocks.beginStructuredAgentSessionProvisionalLaunch.mockImplementation((args) => {
|
||||
args.beforeOpen?.('session-1')
|
||||
return { sessionId: 'session-1', tab: { id: 'agent-session:session-1' }, settlement }
|
||||
})
|
||||
|
||||
await resumeAiVaultSessionInNewChat(source, 'codex', 'worktree-1', 'resume-click')
|
||||
|
||||
expect(mocks.prepareAiVaultSessionForResume).toHaveBeenCalledWith(source)
|
||||
expect(mocks.beginStructuredAgentSessionProvisionalLaunch).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
plan: expect.objectContaining({ resumeFrom: { providerSessionId: 'provider-1' } }),
|
||||
hooks: {}
|
||||
})
|
||||
)
|
||||
expect(mocks.activateAndRevealWorkspace).toHaveBeenCalledWith('worktree-1', {
|
||||
executionHostId: 'local'
|
||||
})
|
||||
expect(mocks.toastError).not.toHaveBeenCalled()
|
||||
expect(source.cwd).toBe('/private/var/example')
|
||||
expect(source.sessionId).toBe(aliases ? 'provider-1' : session.sessionId)
|
||||
settle({ kind: 'structured', sessionId: 'session-1' })
|
||||
}
|
||||
)
|
||||
|
||||
// Where `opencode` is 1.x, only the OpenCode 2 chat can load a 2.x conversation.
|
||||
it.each([
|
||||
['admitted', 'opencode2'],
|
||||
['declined', 'opencode'],
|
||||
// Not a refusal: switching would start `opencode`, which may be 1.x.
|
||||
['unreachable', 'opencode2'],
|
||||
['workspace-unresolved', 'opencode2']
|
||||
])(
|
||||
'opens an OpenCode 2 row in the OpenCode 2 chat, else an OpenCode chat (%s)',
|
||||
async (kind, agent) => {
|
||||
mocks.admitStructuredLaunchOnHost.mockResolvedValue({ kind })
|
||||
await resumeAiVaultSessionInNewChat(session, 'opencode2', 'worktree-1', 'resume-click')
|
||||
|
||||
expect(mocks.admitStructuredLaunchOnHost).toHaveBeenCalledExactlyOnceWith(
|
||||
{ kind: 'local' },
|
||||
'id:worktree-1',
|
||||
'opencode2'
|
||||
)
|
||||
expect(mocks.beginStructuredAgentSessionProvisionalLaunch).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ plan: expect.objectContaining({ agent }) })
|
||||
)
|
||||
}
|
||||
)
|
||||
|
||||
it('asks the host nothing for a row only one chat takes over', async () => {
|
||||
await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
|
||||
expect(mocks.admitStructuredLaunchOnHost).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it.each(['refusal', 'success', 'newer-navigation'] as const)(
|
||||
'keeps sleeping History cold until actual creation: %s',
|
||||
async (outcome) => {
|
||||
mocks.sleeping = true
|
||||
let settle!: (value: StructuredAgentLaunchSettlement) => void
|
||||
const settlement = new Promise<StructuredAgentLaunchSettlement>((resolve) => {
|
||||
settle = resolve
|
||||
})
|
||||
mocks.beginStructuredAgentSessionProvisionalLaunch.mockImplementation((args) => {
|
||||
args.beforeOpen?.('session-1')
|
||||
return { sessionId: 'session-1', tab: { id: 'agent-session:session-1' }, settlement }
|
||||
})
|
||||
await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
|
||||
expect(mocks.activateAndRevealWorkspace).not.toHaveBeenCalled()
|
||||
if (outcome === 'newer-navigation') {
|
||||
mocks.navigationIndex += 1
|
||||
}
|
||||
settle(
|
||||
outcome === 'refusal'
|
||||
? { kind: 'failed', error: new Error('refused') }
|
||||
: { kind: 'structured', sessionId: 'session-1' }
|
||||
)
|
||||
await settlement
|
||||
expect(mocks.activateAndRevealWorkspace).toHaveBeenCalledTimes(outcome === 'success' ? 1 : 0)
|
||||
expect(mocks.toastError).toHaveBeenCalledTimes(outcome === 'refusal' ? 1 : 0)
|
||||
}
|
||||
)
|
||||
|
||||
it.each([
|
||||
['agent_session_conflict', undefined, 'Another chat is already holding this conversation.'],
|
||||
[
|
||||
'agent_session_conflict',
|
||||
'conversationHeldElsewhere',
|
||||
'Codex is running this conversation in another terminal. Quit it there or close that terminal, then try again.'
|
||||
],
|
||||
[
|
||||
'agent_session_identity_required',
|
||||
'transcriptNotFound',
|
||||
"Codex hasn't saved this conversation yet. Try again after it replies."
|
||||
],
|
||||
[
|
||||
'agent_session_identity_required',
|
||||
'transcriptUnreadable',
|
||||
"This conversation's history could not be loaded, so it cannot be resumed in chat."
|
||||
]
|
||||
])('toasts the eventual %s refusal', async (code, reason, message) => {
|
||||
const error = Object.assign(new Error('Host diagnostic'), {
|
||||
code,
|
||||
...(reason ? { refusal: { code, details: { reason } } } : {})
|
||||
})
|
||||
mocks.beginStructuredAgentSessionProvisionalLaunch.mockReturnValue({
|
||||
sessionId: 'session-1',
|
||||
tab: { id: 'agent-session:session-1' },
|
||||
settlement: Promise.resolve({ kind: 'failed', error })
|
||||
})
|
||||
|
||||
await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
|
||||
await vi.waitFor(() => expect(mocks.toastError).toHaveBeenCalledExactlyOnceWith(message))
|
||||
})
|
||||
|
||||
it('keeps unknown outcomes silent for reconciliation', async () => {
|
||||
mocks.beginStructuredAgentSessionProvisionalLaunch.mockReturnValue({
|
||||
sessionId: 'session-1',
|
||||
tab: { id: 'agent-session:session-1' },
|
||||
settlement: Promise.resolve({ kind: 'visibility-unknown', sessionId: 'session-1' })
|
||||
})
|
||||
|
||||
await resumeAiVaultSessionInNewChat(session, 'codex', 'worktree-1', 'resume-click')
|
||||
await Promise.resolve()
|
||||
expect(mocks.toastError).not.toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
+2
-525
@@ -2,15 +2,8 @@ import { describe, expect, it } from 'vitest'
|
||||
import type { Repo } from '../../../../../../shared/repo-types'
|
||||
import type { Worktree } from '../../../../../../shared/worktree/types'
|
||||
import type { AiVaultSessionWorktreeInfo } from '../../../../../../shared/ai-vault/session-display/ai-vault-session-worktree'
|
||||
import { folderWorkspaceKey } from '../../../../../../shared/workspace-scope'
|
||||
import { resolveAiVaultSessionLaunchTarget } from './ai-vault-session-launch-target'
|
||||
import {
|
||||
aiVaultSessionResumeLabel,
|
||||
aiVaultSessionRowResumeGating,
|
||||
type AiVaultSessionResumeTargetState,
|
||||
resolveAiVaultSessionResumeActions,
|
||||
resolveAiVaultSessionResumeState
|
||||
} from './ai-vault-session-resume'
|
||||
|
||||
import { resolveAiVaultSessionResumeState } from './ai-vault-session-resume'
|
||||
|
||||
function makeWorktree(overrides: Partial<Worktree> = {}): Worktree {
|
||||
return {
|
||||
@@ -46,57 +39,6 @@ function makeRepo(overrides: Partial<Repo> = {}): Repo {
|
||||
}
|
||||
}
|
||||
|
||||
function makeTargetState(
|
||||
overrides: Partial<AiVaultSessionResumeTargetState> = {}
|
||||
): AiVaultSessionResumeTargetState {
|
||||
return {
|
||||
folderWorkspaces: [],
|
||||
projectGroups: [],
|
||||
repos: [],
|
||||
worktreesByRepo: {},
|
||||
...overrides
|
||||
}
|
||||
}
|
||||
|
||||
function makeFolderTargetState(
|
||||
projectGroup: Partial<AiVaultSessionResumeTargetState['projectGroups'][number]>
|
||||
): AiVaultSessionResumeTargetState {
|
||||
return makeTargetState({
|
||||
folderWorkspaces: [
|
||||
{
|
||||
id: 'folder-1',
|
||||
projectGroupId: 'group-1',
|
||||
name: 'Platform',
|
||||
folderPath: '/repo/platform',
|
||||
linkedTask: null,
|
||||
comment: '',
|
||||
isArchived: false,
|
||||
isUnread: false,
|
||||
isPinned: false,
|
||||
sortOrder: 0,
|
||||
lastActivityAt: 1,
|
||||
createdAt: 1,
|
||||
updatedAt: 1
|
||||
}
|
||||
],
|
||||
projectGroups: [
|
||||
{
|
||||
id: 'group-1',
|
||||
name: 'Platform',
|
||||
parentPath: null,
|
||||
parentGroupId: null,
|
||||
createdFrom: 'manual',
|
||||
tabOrder: 0,
|
||||
isCollapsed: false,
|
||||
color: null,
|
||||
createdAt: 1,
|
||||
updatedAt: 1,
|
||||
...projectGroup
|
||||
}
|
||||
]
|
||||
})
|
||||
}
|
||||
|
||||
function makeWorktreeInfo(
|
||||
status: AiVaultSessionWorktreeInfo['status']
|
||||
): AiVaultSessionWorktreeInfo {
|
||||
@@ -109,8 +51,6 @@ function makeWorktreeInfo(
|
||||
}
|
||||
|
||||
const HOST_SESSION_FILE = '/Users/ada/.claude/projects/-repo-orca/session-1.jsonl'
|
||||
const WSL_SESSION_FILE =
|
||||
'\\\\wsl$\\Ubuntu\\home\\ada\\.claude\\projects\\-repo-orca\\session-1.jsonl'
|
||||
|
||||
describe('resolveAiVaultSessionResumeState', () => {
|
||||
it('prefers the session worktree over the active workspace', () => {
|
||||
@@ -132,154 +72,6 @@ describe('resolveAiVaultSessionResumeState', () => {
|
||||
})
|
||||
})
|
||||
|
||||
it('falls back to the active workspace when the session worktree is unavailable', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('archived'),
|
||||
activeWorktreeId: 'repo-1::/repo/orca',
|
||||
worktrees: [makeWorktree()],
|
||||
repos: [{ id: 'repo-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: 'repo-1::/repo/orca',
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
|
||||
it('blocks missing worktrees even when the repo is SSH-owned', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: null,
|
||||
worktrees: [],
|
||||
repos: [{ id: 'repo-1', connectionId: 'ssh-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: true,
|
||||
worktreeId: null,
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
|
||||
it('allows SSH-owned session worktrees', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: null,
|
||||
worktrees: [makeWorktree()],
|
||||
repos: [makeRepo({ connectionId: 'ssh-1' })]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: 'repo-1::/repo/orca',
|
||||
usesSessionWorktree: true
|
||||
})
|
||||
})
|
||||
|
||||
it('allows SSH-stamped worktrees even when the repo owner is runtime', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: null,
|
||||
worktrees: [makeWorktree({ hostId: 'ssh:ssh-1' })],
|
||||
repos: [makeRepo({ connectionId: null, executionHostId: 'runtime:env-1' })]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: 'repo-1::/repo/orca',
|
||||
usesSessionWorktree: true
|
||||
})
|
||||
})
|
||||
|
||||
it('allows runtime-owned targets for matching runtime sessions', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
sessionExecutionHostId: 'runtime:env-1',
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: null,
|
||||
worktrees: [makeWorktree()],
|
||||
repos: [
|
||||
makeRepo({
|
||||
connectionId: null,
|
||||
executionHostId: 'runtime:env-1'
|
||||
})
|
||||
]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: 'repo-1::/repo/orca',
|
||||
usesSessionWorktree: true
|
||||
})
|
||||
})
|
||||
|
||||
it('blocks runtime-owned targets for sessions from another host', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
sessionExecutionHostId: 'local',
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: null,
|
||||
worktrees: [makeWorktree()],
|
||||
repos: [
|
||||
makeRepo({
|
||||
connectionId: null,
|
||||
executionHostId: 'runtime:env-1'
|
||||
})
|
||||
]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: true,
|
||||
worktreeId: null,
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
|
||||
it('allows runtime-stamped worktrees even when the repo owner is local', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
sessionExecutionHostId: 'runtime:env-1',
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: null,
|
||||
worktrees: [makeWorktree({ hostId: 'runtime:env-1' })],
|
||||
repos: [makeRepo({ connectionId: null, executionHostId: 'local' })]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: 'repo-1::/repo/orca',
|
||||
usesSessionWorktree: true
|
||||
})
|
||||
})
|
||||
|
||||
it('prefers the session worktree when the active workspace is SSH-owned', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: 'repo-2::/remote/orca',
|
||||
worktrees: [
|
||||
makeWorktree(),
|
||||
makeWorktree({
|
||||
id: 'repo-2::/remote/orca',
|
||||
repoId: 'repo-2',
|
||||
path: '/remote/orca'
|
||||
})
|
||||
],
|
||||
repos: [{ id: 'repo-1' } as Repo, { id: 'repo-2', connectionId: 'ssh-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: 'repo-1::/repo/orca',
|
||||
usesSessionWorktree: true
|
||||
})
|
||||
})
|
||||
|
||||
it('falls back to the active workspace when the session worktree is runtime-owned', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
@@ -310,319 +102,4 @@ describe('resolveAiVaultSessionResumeState', () => {
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
|
||||
it('falls back to an active SSH folder workspace', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('archived'),
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
worktrees: [],
|
||||
repos: [],
|
||||
targetState: makeFolderTargetState({ id: 'group-1', connectionId: 'ssh-1' })
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: folderWorkspaceKey('folder-1'),
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
|
||||
it('blocks host-stored sessions when only an SSH workspace is open', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('archived'),
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
worktrees: [],
|
||||
repos: [],
|
||||
targetState: makeFolderTargetState({ id: 'group-1', connectionId: 'ssh-1' })
|
||||
})
|
||||
).toEqual({
|
||||
blocked: true,
|
||||
worktreeId: null,
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
|
||||
it('allows an active runtime folder workspace for matching runtime sessions', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeState({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
sessionExecutionHostId: 'runtime:env-1',
|
||||
worktreeInfo: makeWorktreeInfo('archived'),
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
worktrees: [],
|
||||
repos: [],
|
||||
targetState: makeFolderTargetState({ id: 'group-1', executionHostId: 'runtime:env-1' })
|
||||
})
|
||||
).toEqual({
|
||||
blocked: false,
|
||||
worktreeId: folderWorkspaceKey('folder-1'),
|
||||
usesSessionWorktree: false
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveAiVaultSessionResumeActions', () => {
|
||||
it('exposes separate session-worktree and active-workspace targets', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: 'repo-1::/repo/other',
|
||||
worktrees: [
|
||||
makeWorktree(),
|
||||
makeWorktree({ id: 'repo-1::/repo/other', path: '/repo/other' })
|
||||
],
|
||||
repos: [{ id: 'repo-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: 'repo-1::/repo/orca', disabled: false },
|
||||
newTab: { worktreeId: 'repo-1::/repo/other', disabled: false }
|
||||
})
|
||||
})
|
||||
|
||||
it('enables an SSH active-workspace action when the session worktree is local', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: 'repo-2::/remote/orca',
|
||||
worktrees: [
|
||||
// A WSL-stored session's own worktree lives in that distro.
|
||||
makeWorktree({ path: '\\\\wsl$\\Ubuntu\\repo\\orca' }),
|
||||
makeWorktree({
|
||||
id: 'repo-2::/remote/orca',
|
||||
repoId: 'repo-2',
|
||||
path: '/remote/orca'
|
||||
})
|
||||
],
|
||||
repos: [{ id: 'repo-1' } as Repo, { id: 'repo-2', connectionId: 'ssh-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: 'repo-1::/repo/orca', disabled: false },
|
||||
newTab: { worktreeId: 'repo-2::/remote/orca', disabled: false }
|
||||
})
|
||||
})
|
||||
|
||||
it('disables the SSH active-workspace action for host-stored sessions', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: 'repo-2::/remote/orca',
|
||||
worktrees: [
|
||||
makeWorktree(),
|
||||
makeWorktree({
|
||||
id: 'repo-2::/remote/orca',
|
||||
repoId: 'repo-2',
|
||||
path: '/remote/orca'
|
||||
})
|
||||
],
|
||||
repos: [{ id: 'repo-1' } as Repo, { id: 'repo-2', connectionId: 'ssh-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: 'repo-1::/repo/orca', disabled: false },
|
||||
newTab: { worktreeId: 'repo-2::/remote/orca', disabled: true }
|
||||
})
|
||||
})
|
||||
|
||||
it('disables runtime-owned targets without disabling local targets', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('active'),
|
||||
activeWorktreeId: 'repo-2::/repo/other',
|
||||
worktrees: [
|
||||
makeWorktree(),
|
||||
makeWorktree({
|
||||
id: 'repo-2::/repo/other',
|
||||
repoId: 'repo-2',
|
||||
path: '/repo/other'
|
||||
})
|
||||
],
|
||||
repos: [
|
||||
makeRepo({ connectionId: null, executionHostId: 'runtime:env-1' }),
|
||||
makeRepo({
|
||||
id: 'repo-2',
|
||||
path: '/repo/other',
|
||||
connectionId: null,
|
||||
executionHostId: 'local'
|
||||
})
|
||||
]
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: 'repo-1::/repo/orca', disabled: true },
|
||||
newTab: { worktreeId: 'repo-2::/repo/other', disabled: false }
|
||||
})
|
||||
})
|
||||
|
||||
it('does not expose the active workspace as a duplicate new-tab target', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('current'),
|
||||
activeWorktreeId: 'repo-1::/repo/orca',
|
||||
worktrees: [makeWorktree()],
|
||||
repos: [{ id: 'repo-1' } as Repo]
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: 'repo-1::/repo/orca', disabled: false },
|
||||
newTab: { worktreeId: null, disabled: true }
|
||||
})
|
||||
})
|
||||
|
||||
it('enables the active folder workspace action when it is local or SSH-owned', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
worktreeInfo: makeWorktreeInfo('archived'),
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
worktrees: [],
|
||||
repos: [],
|
||||
targetState: makeFolderTargetState({ id: 'group-1', connectionId: 'ssh-1' })
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: null, disabled: true },
|
||||
newTab: { worktreeId: folderWorkspaceKey('folder-1'), disabled: false }
|
||||
})
|
||||
})
|
||||
|
||||
it('enables the active folder workspace action when it is a matching runtime host', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionResumeActions({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
sessionExecutionHostId: 'runtime:env-1',
|
||||
worktreeInfo: makeWorktreeInfo('archived'),
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
worktrees: [],
|
||||
repos: [],
|
||||
targetState: makeFolderTargetState({ id: 'group-1', executionHostId: 'runtime:env-1' })
|
||||
})
|
||||
).toEqual({
|
||||
worktree: { worktreeId: null, disabled: true },
|
||||
newTab: { worktreeId: folderWorkspaceKey('folder-1'), disabled: false }
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('resolveAiVaultSessionLaunchTarget', () => {
|
||||
it('allows direct resume into an active SSH folder workspace', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionLaunchTarget({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
targetState: makeFolderTargetState({ id: 'group-1', connectionId: 'ssh-1' })
|
||||
})
|
||||
).toEqual({
|
||||
status: 'ready',
|
||||
worktreeId: folderWorkspaceKey('folder-1')
|
||||
})
|
||||
})
|
||||
|
||||
it('blocks direct resume of a host-stored session into an SSH folder workspace', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionLaunchTarget({
|
||||
sessionFilePath: HOST_SESSION_FILE,
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
targetState: makeFolderTargetState({ id: 'group-1', connectionId: 'ssh-1' })
|
||||
})
|
||||
).toEqual({
|
||||
status: 'unsupported',
|
||||
targetStatus: 'ssh'
|
||||
})
|
||||
})
|
||||
|
||||
it('allows direct resume into a matching runtime folder workspace', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionLaunchTarget({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
sessionExecutionHostId: 'runtime:env-1',
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
targetState: makeFolderTargetState({ id: 'group-1', executionHostId: 'runtime:env-1' })
|
||||
})
|
||||
).toEqual({
|
||||
status: 'ready',
|
||||
worktreeId: folderWorkspaceKey('folder-1')
|
||||
})
|
||||
})
|
||||
|
||||
it('blocks direct resume into a mismatched runtime folder workspace', () => {
|
||||
expect(
|
||||
resolveAiVaultSessionLaunchTarget({
|
||||
sessionFilePath: WSL_SESSION_FILE,
|
||||
sessionExecutionHostId: 'runtime:env-2',
|
||||
activeWorktreeId: folderWorkspaceKey('folder-1'),
|
||||
targetState: makeFolderTargetState({ id: 'group-1', executionHostId: 'runtime:env-1' })
|
||||
})
|
||||
).toEqual({
|
||||
status: 'unsupported',
|
||||
targetStatus: 'runtime'
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('aiVaultSessionResumeLabel', () => {
|
||||
it('names the session worktree action distinctly from the active-workspace fallback', () => {
|
||||
expect(aiVaultSessionResumeLabel({ usesSessionWorktree: true })).toBe('Resume in Worktree')
|
||||
expect(aiVaultSessionResumeLabel({ usesSessionWorktree: false })).toBe('Resume in New Tab')
|
||||
})
|
||||
})
|
||||
|
||||
describe('aiVaultSessionRowResumeGating', () => {
|
||||
const zeroTurnSession = { messageCount: 0, previewMessages: [] }
|
||||
const sessionWithTurns = { messageCount: 3, previewMessages: [] }
|
||||
const unblocked = { blocked: false }
|
||||
|
||||
it('withholds every resume affordance for a zero-turn session', () => {
|
||||
expect(aiVaultSessionRowResumeGating(zeroTurnSession, unblocked)).toEqual({
|
||||
resumeDisabled: true,
|
||||
canCopyResumeCommand: false
|
||||
})
|
||||
})
|
||||
|
||||
it('keeps copy-resume available when only the workspace target is blocked', () => {
|
||||
expect(aiVaultSessionRowResumeGating(sessionWithTurns, { blocked: true })).toEqual({
|
||||
resumeDisabled: true,
|
||||
canCopyResumeCommand: true
|
||||
})
|
||||
expect(aiVaultSessionRowResumeGating(sessionWithTurns, null)).toEqual({
|
||||
resumeDisabled: true,
|
||||
canCopyResumeCommand: true
|
||||
})
|
||||
})
|
||||
|
||||
it('withholds copy-resume from a native structured session', () => {
|
||||
expect(
|
||||
aiVaultSessionRowResumeGating(
|
||||
{
|
||||
...sessionWithTurns,
|
||||
structuredSession: { sessionId: 'session-1', workspaceId: 'worktree-1' }
|
||||
},
|
||||
unblocked
|
||||
)
|
||||
).toEqual({
|
||||
resumeDisabled: false,
|
||||
canCopyResumeCommand: false
|
||||
})
|
||||
})
|
||||
|
||||
it('treats user/assistant previews as resumable content when the turn count is unknown', () => {
|
||||
const previewOnlySession = {
|
||||
messageCount: 0,
|
||||
previewMessages: [{ role: 'user' as const, text: 'hello', timestamp: null }]
|
||||
}
|
||||
expect(aiVaultSessionRowResumeGating(previewOnlySession, unblocked)).toEqual({
|
||||
resumeDisabled: false,
|
||||
canCopyResumeCommand: true
|
||||
})
|
||||
})
|
||||
|
||||
it('enables resume for an unblocked session with turns', () => {
|
||||
expect(aiVaultSessionRowResumeGating(sessionWithTurns, unblocked)).toEqual({
|
||||
resumeDisabled: false,
|
||||
canCopyResumeCommand: true
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
+1
-56
@@ -7,13 +7,12 @@ import { ConfirmationDialogProvider } from '@/components/confirmation-dialog'
|
||||
import { useAppStore } from '@/store/index'
|
||||
import { makeRepo, makeWorktree } from '../../../worktree-jump/worktree-jump-palette-test-fixtures'
|
||||
import { openAgentSessionHistoryModal } from '../panel/agent-session-history-modal'
|
||||
import { resolveAiVaultPanelSessionListRequest } from '../scanning/ai-vault-panel-session-list-request'
|
||||
|
||||
import type {
|
||||
AiVaultAgent,
|
||||
AiVaultSession
|
||||
} from '../../../../../../shared/ai-vault/contracts/ai-vault-types'
|
||||
import type { AiVaultSessionListGroup } from './ai-vault-session-filters'
|
||||
import { AI_VAULT_VIEW_OPTIONS_STORAGE_KEY } from '../scope/ai-vault-view-options-persistence'
|
||||
|
||||
const mocks = vi.hoisted(() => ({
|
||||
scopePaths: new Array<readonly string[]>(),
|
||||
@@ -97,31 +96,6 @@ function openHistory(initialQuery = '', agent?: AiVaultAgent) {
|
||||
)
|
||||
}
|
||||
|
||||
function chatSession(agent: AiVaultAgent): AiVaultSession {
|
||||
return {
|
||||
id: `${agent}-chat`,
|
||||
executionHostId: 'local',
|
||||
agent,
|
||||
sessionId: agent,
|
||||
title: agent,
|
||||
cwd: '/repo/chat',
|
||||
branch: null,
|
||||
model: null,
|
||||
filePath: `/tmp/${agent}.jsonl`,
|
||||
codexHome: null,
|
||||
createdAt: null,
|
||||
updatedAt: null,
|
||||
modifiedAt: '2026-10-13T00:00:00.000Z',
|
||||
messageCount: 2,
|
||||
totalTokens: 0,
|
||||
previewMessages: [],
|
||||
queuedMessageCount: 0,
|
||||
subagentTranscriptCount: 0,
|
||||
resumeCommand: '',
|
||||
subagent: null
|
||||
}
|
||||
}
|
||||
|
||||
function dialogSearch(): HTMLInputElement {
|
||||
return within(screen.getByRole('dialog')).getByLabelText<HTMLInputElement>('Search sessions')
|
||||
}
|
||||
@@ -176,23 +150,6 @@ describe('Session History dialog', () => {
|
||||
expect(composer).not.toHaveFocus()
|
||||
})
|
||||
|
||||
it("opens on the chat's workspace with the search filled; Escape clears, then closes", async () => {
|
||||
render(<Host />)
|
||||
const composer = screen.getByLabelText('Composer')
|
||||
composer.focus()
|
||||
openHistory('auth')
|
||||
await waitFor(() => expect(dialogSearch()).toHaveFocus())
|
||||
expect(dialogSearch().value).toBe('auth')
|
||||
const chatRequest = resolveAiVaultPanelSessionListRequest(useAppStore.getState(), CHAT_WORKTREE)
|
||||
expect(mocks.scopePaths.at(-1)).toEqual(chatRequest.scopePaths)
|
||||
|
||||
fireEvent.keyDown(dialogSearch(), { key: 'Escape' })
|
||||
expect(dialogSearch().value).toBe('')
|
||||
fireEvent.keyDown(dialogSearch(), { key: 'Escape' })
|
||||
expect(useAppStore.getState().activeModal).toBe('none')
|
||||
await waitFor(() => expect(composer).toHaveFocus())
|
||||
})
|
||||
|
||||
it("keeps its search apart from the sidebar's and leaves Settings' request to the sidebar", async () => {
|
||||
render(<Host withSidebar />)
|
||||
const sidebarSearch = within(screen.getByTestId('sidebar')).getByLabelText<HTMLInputElement>(
|
||||
@@ -210,16 +167,4 @@ describe('Session History dialog', () => {
|
||||
).toBeInTheDocument()
|
||||
expect(useAppStore.getState().aiVaultSearchFocusRequested).toBe(false)
|
||||
})
|
||||
|
||||
it("starts on the chat's agent without touching the sidebar's saved filter", () => {
|
||||
mocks.sessions = [chatSession('claude'), chatSession('codex')]
|
||||
window.localStorage.removeItem(AI_VAULT_VIEW_OPTIONS_STORAGE_KEY)
|
||||
render(<Host />)
|
||||
openHistory('', 'claude')
|
||||
|
||||
const dialog = within(screen.getByRole('dialog'))
|
||||
expect(dialog.getByText('claude-chat')).toBeInTheDocument()
|
||||
expect(dialog.queryByText('codex-chat')).toBeNull()
|
||||
expect(window.localStorage.getItem(AI_VAULT_VIEW_OPTIONS_STORAGE_KEY)).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
+1
-86
@@ -4,11 +4,9 @@ import { act, cleanup, render, screen } from '@testing-library/react'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { AgentSessionStatusEvent } from '../../../../../../shared/agent-session/agent-session-wire'
|
||||
import type { AiVaultSession } from '../../../../../../shared/ai-vault/contracts/ai-vault-types'
|
||||
import type { AiVaultSearchHit } from '../../../../../../shared/ai-vault/search/ai-vault-search-types'
|
||||
|
||||
import type { ExecutionHostId } from '../../../../../../shared/execution-host'
|
||||
import type { Tab } from '../../../../../../shared/tab-types'
|
||||
import { AGENT_SESSION_WORKSPACE_SLEEP_MARK_RUNTIME_CAPABILITY } from '../../../../../../shared/agent-session/agent-session-workspace-sleep'
|
||||
import { AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY } from '../../../../../../shared/agent-session/agent-session-attention-capabilities'
|
||||
|
||||
const mocks = vi.hoisted(() => ({ subscribe: vi.fn(), supports: vi.fn() }))
|
||||
vi.mock('@/runtime/structured-agent-session-client', () => ({
|
||||
@@ -26,7 +24,6 @@ import {
|
||||
resetStructuredAgentSessionStatusFeedsForTests
|
||||
} from '@/runtime/structured-agent-session-status-feed'
|
||||
import { VaultSessionRow } from './AiVaultSessionRow'
|
||||
import { aiVaultSearchHitToSession } from '../search/ai-vault-search-session'
|
||||
|
||||
const initialState = useAppStore.getInitialState()
|
||||
const emitters = new Map<string, (event: AgentSessionStatusEvent) => void>()
|
||||
@@ -60,29 +57,6 @@ function row(host: ExecutionHostId = 'local', title = 'Codex Chat'): AiVaultSess
|
||||
}
|
||||
}
|
||||
|
||||
function searchRow(): AiVaultSession {
|
||||
const hit: AiVaultSearchHit = {
|
||||
agent: 'codex',
|
||||
sessionId: 'provider-session',
|
||||
title: 'Codex Chat',
|
||||
cwd: '/folder',
|
||||
branch: null,
|
||||
updatedAt: null,
|
||||
messageCount: 1,
|
||||
score: 1,
|
||||
source: {
|
||||
presence: 'present',
|
||||
filePath: '/sessions/provider-session.jsonl'
|
||||
},
|
||||
evidence: null,
|
||||
structuredSession: {
|
||||
workspaceId: 'folder-workspace',
|
||||
sessionId: 'native-session'
|
||||
}
|
||||
}
|
||||
return aiVaultSearchHitToSession(hit, 'local')
|
||||
}
|
||||
|
||||
function tab(customLabel: string | null = null): Tab {
|
||||
return {
|
||||
id: 'native-tab',
|
||||
@@ -189,50 +163,6 @@ describe('native chat names in Vault rows', () => {
|
||||
expect(screen.queryByText('Codex Chat')).toBeNull()
|
||||
})
|
||||
|
||||
it.each([
|
||||
['list', row],
|
||||
['search', searchRow]
|
||||
])(
|
||||
'lets a manual tab rename win in a %s row, and returns to the name once cleared',
|
||||
async (_kind, make) => {
|
||||
useAppStore.setState({
|
||||
unifiedTabsByWorktree: { 'folder-workspace': [tab('Manual name')] }
|
||||
})
|
||||
await renderRow(make())
|
||||
publish('local', 'Explain the parser')
|
||||
expect(screen.getByText('Manual name')).toBeTruthy()
|
||||
act(() =>
|
||||
useAppStore.setState({
|
||||
unifiedTabsByWorktree: { 'folder-workspace': [tab()] }
|
||||
})
|
||||
)
|
||||
expect(screen.getByText('Explain the parser')).toBeTruthy()
|
||||
}
|
||||
)
|
||||
|
||||
it.each(['constructor', '__proto__'])(
|
||||
'renders a paired row whose workspace id names an object member (%s)',
|
||||
async (workspaceId) => {
|
||||
await renderRow({
|
||||
...row('local', 'Host row title'),
|
||||
structuredSession: { workspaceId, sessionId: 'native-session' }
|
||||
})
|
||||
expect(screen.getByText('Host row title')).toBeTruthy()
|
||||
}
|
||||
)
|
||||
|
||||
it('ignores a published name no record store would hold', async () => {
|
||||
await renderRow(row('local', 'Host row title'))
|
||||
publish('local', 'x'.repeat(201))
|
||||
expect(screen.getByText('Host row title')).toBeTruthy()
|
||||
})
|
||||
|
||||
it('keeps the host row title for a chat the feed has not named, as after a restart', async () => {
|
||||
await renderRow(row('local', 'Named before restart'))
|
||||
publish('local')
|
||||
expect(screen.getByText('Named before restart')).toBeTruthy()
|
||||
})
|
||||
|
||||
it('never shows a name another host published for the same session id', async () => {
|
||||
mocks.supports.mockResolvedValue(true)
|
||||
const releaseLocal = getStructuredAgentSessionStatusFeed({
|
||||
@@ -246,19 +176,4 @@ describe('native chat names in Vault rows', () => {
|
||||
expect(screen.queryByText('Local chat name')).toBeNull()
|
||||
releaseLocal()
|
||||
})
|
||||
|
||||
it('keeps the host row title from an older paired host without probing it again', async () => {
|
||||
mocks.supports.mockResolvedValue(false)
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
await renderRow(row('runtime:older', 'Saved by older host'))
|
||||
await act(async () => {
|
||||
await vi.advanceTimersByTimeAsync(60_000)
|
||||
})
|
||||
expect(screen.getByText('Saved by older host')).toBeTruthy()
|
||||
expect(mocks.supports.mock.calls).toEqual([
|
||||
['older', AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY],
|
||||
['older', AGENT_SESSION_WORKSPACE_SLEEP_MARK_RUNTIME_CAPABILITY]
|
||||
])
|
||||
expect(mocks.subscribe).not.toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
|
||||
+2
-198
@@ -1,23 +1,17 @@
|
||||
// @vitest-environment happy-dom
|
||||
|
||||
import { act, cleanup, fireEvent, render, screen, within } from '@testing-library/react'
|
||||
import { cleanup, fireEvent, render, screen } from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { TooltipProvider } from '@/components/ui/tooltip'
|
||||
import type { AiVaultSession } from '../../../../../../shared/ai-vault/contracts/ai-vault-types'
|
||||
import type { AiVaultSessionWorktreeInfo } from '../../../../../../shared/ai-vault/session-display/ai-vault-session-worktree'
|
||||
import { searchHit } from '../../../../../../shared/ai-vault/search/ai-vault-search-test-fixture'
|
||||
import type { AiVaultSearchHit } from '../../../../../../shared/ai-vault/search/ai-vault-search-types'
|
||||
import type { AiVaultSubagentResumeActions } from './AiVaultSessionSubagents'
|
||||
import { findAiVaultSessionLiveState } from '../session-actions/ai-vault-original-pane'
|
||||
|
||||
import { VaultSessionRow } from './AiVaultSessionRow'
|
||||
|
||||
import type { AgentDotState } from '@/components/AgentStateDot'
|
||||
import type { AgentStatusEntry } from '../../../../../../shared/agent-status/contracts/agent-status-types'
|
||||
import {
|
||||
buildAiVaultOriginalPaneIndex,
|
||||
findAiVaultSessionLiveStateInIndex
|
||||
} from '../session-actions/ai-vault-original-pane-index'
|
||||
|
||||
const session = {
|
||||
id: 'local:gemini:sess-1:/home/a/.gemini/s.json',
|
||||
@@ -42,12 +36,6 @@ const session = {
|
||||
subagent: null
|
||||
} as unknown as AiVaultSession
|
||||
|
||||
const worktreeInfo: AiVaultSessionWorktreeInfo = {
|
||||
status: 'active',
|
||||
label: 'feature-branch',
|
||||
path: '/home/a/worktrees/feature-branch'
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
// Expanded details read first-prompt/subagent APIs during render/mount.
|
||||
;(window as unknown as { api: unknown }).api = {
|
||||
@@ -115,79 +103,6 @@ function renderRow(
|
||||
)
|
||||
}
|
||||
|
||||
it.each([true, false])(
|
||||
'renders the selected pane status through the %s provider lookup',
|
||||
(direct) => {
|
||||
const selectedSession = { ...session, title: 'Monitor the background job until it finishes' }
|
||||
const selected: AgentStatusEntry = {
|
||||
paneKey: 'tab:leaf',
|
||||
state: 'working',
|
||||
workingMode: 'monitoring',
|
||||
agentType: session.agent,
|
||||
prompt: selectedSession.title,
|
||||
updatedAt: 100,
|
||||
stateStartedAt: 100,
|
||||
stateHistory: [],
|
||||
...(direct ? { providerSession: { key: 'session_id', id: session.sessionId } } : {})
|
||||
}
|
||||
const lookup = (entries: AgentStatusEntry[]) => {
|
||||
const state = {
|
||||
agentStatusByPaneKey: Object.fromEntries(entries.map((entry, i) => [String(i), entry])),
|
||||
retainedAgentsByPaneKey: {},
|
||||
sleepingAgentSessionsByPaneKey: {},
|
||||
tabsByWorktree: {},
|
||||
terminalLayoutsByTabId: {}
|
||||
}
|
||||
const indexed = findAiVaultSessionLiveStateInIndex(
|
||||
buildAiVaultOriginalPaneIndex(state),
|
||||
selectedSession
|
||||
)
|
||||
expect(findAiVaultSessionLiveState(state, selectedSession)).toBe(indexed)
|
||||
return indexed
|
||||
}
|
||||
renderRow({ liveState: lookup([selected]) })
|
||||
expect(screen.getByLabelText('Monitoring background tasks')).toBeTruthy()
|
||||
cleanup()
|
||||
renderRow({ liveState: lookup([{ ...selected, workingMode: undefined }]) })
|
||||
expect(screen.getByLabelText('Working')).toBeTruthy()
|
||||
cleanup()
|
||||
renderRow({
|
||||
liveState: lookup([{ ...selected, state: 'done', workingMode: undefined, interrupted: true }])
|
||||
})
|
||||
expect(screen.getByLabelText('Interrupted')).toBeTruthy()
|
||||
for (const [outcome, label] of [
|
||||
['failure', 'Failed'],
|
||||
['unconfirmed', 'Couldn’t confirm']
|
||||
] as const) {
|
||||
cleanup()
|
||||
renderRow({
|
||||
liveState: lookup([
|
||||
{
|
||||
...selected,
|
||||
state: 'done',
|
||||
workingMode: undefined,
|
||||
mainAgent: { state: 'done', outcome, stateStartedAt: 100 }
|
||||
}
|
||||
])
|
||||
})
|
||||
expect(screen.getByLabelText(label)).toBeTruthy()
|
||||
}
|
||||
cleanup()
|
||||
renderRow({ liveState: lookup([{ ...selected, state: 'done', workingMode: undefined }]) })
|
||||
expect(screen.queryByLabelText('Done')).toBeNull()
|
||||
if (!direct) {
|
||||
expect(lookup([selected, selected])).toBeNull()
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
function expectAgentIdentity(): void {
|
||||
const metadata = screen.getByTestId('ai-vault-session-metadata')
|
||||
expect(metadata.querySelector('svg, img')).toBeTruthy()
|
||||
expect(within(metadata).getByText('Gemini')).toBeTruthy()
|
||||
expect(within(metadata).getByText('2 msgs')).toBeTruthy()
|
||||
}
|
||||
|
||||
describe('VaultSessionRow details toggle', () => {
|
||||
it('does not expand the row when a menu action is chosen', async () => {
|
||||
// Portaled menu clicks still bubble through React; Delete must not expand the row behind its dialog.
|
||||
@@ -202,19 +117,6 @@ describe('VaultSessionRow details toggle', () => {
|
||||
expect(onRequestDelete).toHaveBeenCalledTimes(1)
|
||||
expect(onToggleDetails).not.toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('still expands when the row itself is clicked', async () => {
|
||||
const onToggleDetails = vi.fn()
|
||||
const { container } = renderRow({ onToggleDetails })
|
||||
const user = userEvent.setup()
|
||||
|
||||
// Pick the first title because Radix asChild repeats the subtree; its click must reach the row body.
|
||||
const title = container.querySelector('[title="Drag to resume in a new tab"]')
|
||||
expect(title).not.toBeNull()
|
||||
await user.click(title as Element)
|
||||
|
||||
expect(onToggleDetails).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('VaultSessionRow in the /resume picker', () => {
|
||||
@@ -260,101 +162,3 @@ describe('VaultSessionRow in the /resume picker', () => {
|
||||
expect(onToggleDetails).toHaveBeenCalledOnce()
|
||||
})
|
||||
})
|
||||
|
||||
describe('VaultSessionRow native session actions', () => {
|
||||
it('shows the jump action instead of Resume for an open structured session', async () => {
|
||||
const onJumpToOriginalPane = vi.fn()
|
||||
const onResume = vi.fn()
|
||||
renderRow({ resumeHidden: true, onJumpToOriginalPane, onResume })
|
||||
|
||||
expect(screen.queryByTestId('ai-vault-session-resume')).toBeNull()
|
||||
fireEvent.click(screen.getByTestId('ai-vault-session-jump-original-pane'))
|
||||
|
||||
expect(onJumpToOriginalPane).toHaveBeenCalledOnce()
|
||||
expect(onResume).not.toHaveBeenCalled()
|
||||
|
||||
const user = userEvent.setup()
|
||||
await user.click(screen.getByTestId('ai-vault-session-more-actions'))
|
||||
expect(await screen.findByRole('menuitem', { name: 'Jump to Original Pane' })).toBeTruthy()
|
||||
expect(screen.queryByRole('menuitem', { name: 'Resume in New Tab' })).toBeNull()
|
||||
})
|
||||
|
||||
it('hides Delete for structured native sessions', async () => {
|
||||
const nativeSession = {
|
||||
...session,
|
||||
structuredSession: { sessionId: 'native-1', workspaceId: 'workspace-1' }
|
||||
}
|
||||
|
||||
renderRow({ session: nativeSession })
|
||||
const user = userEvent.setup()
|
||||
await user.click(screen.getByTestId('ai-vault-session-more-actions'))
|
||||
|
||||
expect(screen.queryByRole('menuitem', { name: 'Delete' })).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('VaultSessionRow agent metadata line', () => {
|
||||
it('shows the agent identity when the row is collapsed', () => {
|
||||
renderRow()
|
||||
|
||||
expectAgentIdentity()
|
||||
expect(screen.getByText(': Ready when you are')).toBeTruthy()
|
||||
})
|
||||
|
||||
it('keeps the agent identity visible while the row is expanded', () => {
|
||||
renderRow({ detailsExpanded: true })
|
||||
|
||||
expectAgentIdentity()
|
||||
expect(screen.getByText('Latest turns')).toBeTruthy()
|
||||
expect(screen.queryByText(': Ready when you are')).toBeNull()
|
||||
})
|
||||
|
||||
it('renders the worktree badge once when expanded', () => {
|
||||
const { container } = renderRow({ detailsExpanded: true, worktreeInfo })
|
||||
|
||||
expect(container.querySelectorAll(`[title="${worktreeInfo.label}"]`)).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
|
||||
it('keeps matching evidence visible in expanded search rows', () => {
|
||||
const { container } = renderRow({ detailsExpanded: true, searchHit: searchHit() })
|
||||
expect(container.querySelector('mark')?.textContent).toBe('needle')
|
||||
})
|
||||
|
||||
it('threads child resume through expanded parent details without resuming the parent', async () => {
|
||||
const child: AiVaultSession = {
|
||||
...session,
|
||||
agent: 'omp',
|
||||
sessionId: 'child',
|
||||
filePath: '/tmp/parent/worker.jsonl',
|
||||
title: 'OMP worker',
|
||||
subagent: { parentSessionId: 'parent', agentType: 'worker', status: 'completed' }
|
||||
}
|
||||
vi.mocked(window.api.aiVault.listSubagentSessions).mockResolvedValue({
|
||||
sessions: [child],
|
||||
issues: []
|
||||
})
|
||||
const resume = {
|
||||
getState: vi.fn(() => ({
|
||||
blocked: false,
|
||||
worktreeId: 'folder:target',
|
||||
usesSessionWorktree: false
|
||||
})),
|
||||
onResume: vi.fn()
|
||||
}
|
||||
renderRow({
|
||||
session: {
|
||||
...session,
|
||||
agent: 'omp',
|
||||
sessionId: 'parent',
|
||||
messageCount: 0,
|
||||
previewMessages: [],
|
||||
subagentTranscriptCount: 1
|
||||
},
|
||||
detailsExpanded: true,
|
||||
subagentResume: resume
|
||||
})
|
||||
await act(async () => {})
|
||||
fireEvent.click(screen.getByTitle('Resume in New Tab'))
|
||||
expect(resume.onResume).toHaveBeenCalledExactlyOnceWith(child, 'folder:target')
|
||||
})
|
||||
|
||||
+1
-223
@@ -3,9 +3,7 @@
|
||||
import type { ComponentProps, JSX } from 'react'
|
||||
import { act, cleanup, fireEvent, render } from '@testing-library/react'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { SubagentExpansionProvider } from './ai-vault-subagent-expansion'
|
||||
import { useAppStore } from '@/store/index'
|
||||
import { createEditorStore } from '@/store/slices/editor-slice-test-harness'
|
||||
|
||||
import { TooltipProvider } from '@/components/ui/tooltip'
|
||||
import type {
|
||||
AiVaultSession,
|
||||
@@ -76,27 +74,6 @@ function makeSubagent(title: string): AiVaultSession {
|
||||
}
|
||||
|
||||
describe('SessionSubagentsSection', () => {
|
||||
it('opens the selected child through its View Log button', async () => {
|
||||
const child = { ...makeSubagent('Worker'), agent: 'omp' as const }
|
||||
const store = createEditorStore()
|
||||
vi.spyOn(useAppStore, 'getState').mockImplementation(store.getState)
|
||||
listSubagentSessions.mockResolvedValueOnce({ sessions: [child], issues: [] })
|
||||
const view = render(<SessionSubagentsSection session={makeSession({ agent: 'omp' })} />)
|
||||
await act(async () => {})
|
||||
|
||||
fireEvent.click(view.getByTitle('View Log'))
|
||||
|
||||
expect(store.getState().openFiles).toEqual([
|
||||
expect.objectContaining({
|
||||
filePath: child.filePath,
|
||||
relativePath: child.filePath,
|
||||
readOnly: true,
|
||||
liveTail: true,
|
||||
runtimeEnvironmentId: null
|
||||
})
|
||||
])
|
||||
})
|
||||
|
||||
it('keeps the loaded list visible while a rescan-triggered refetch is in flight', async () => {
|
||||
listSubagentSessions.mockResolvedValueOnce({
|
||||
sessions: [makeSubagent('First pass')],
|
||||
@@ -124,92 +101,6 @@ describe('SessionSubagentsSection', () => {
|
||||
expect(queryByText('Second pass')).not.toBeNull()
|
||||
expect(queryByText('First pass')).toBeNull()
|
||||
})
|
||||
|
||||
it('labels the subagent run state exactly once, on the dot itself', async () => {
|
||||
listSubagentSessions.mockResolvedValueOnce({
|
||||
sessions: [makeSubagent('Running task')],
|
||||
issues: []
|
||||
})
|
||||
const { container } = render(<SessionSubagentsSection session={makeSession()} />)
|
||||
await act(async () => {})
|
||||
|
||||
const titles = [...container.querySelectorAll('[title]')].map((element) =>
|
||||
element.getAttribute('title')
|
||||
)
|
||||
|
||||
expect(titles).toEqual(['Running task', 'View Log'])
|
||||
expect(container.querySelector('[data-slot="tooltip-trigger"]')).not.toBeNull()
|
||||
})
|
||||
|
||||
it('does not fetch for remote sessions even when the scan counted transcripts', async () => {
|
||||
const { container } = render(
|
||||
<SessionSubagentsSection
|
||||
session={makeSession({ executionHostId: 'ssh:dev-box', subagentTranscriptCount: 2 })}
|
||||
/>
|
||||
)
|
||||
await act(async () => {})
|
||||
expect(listSubagentSessions).not.toHaveBeenCalled()
|
||||
expect(container.firstChild).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('independent child resume', () => {
|
||||
const child = makeSession({
|
||||
agent: 'omp',
|
||||
sessionId: 'child-id',
|
||||
filePath: '/repo/session/tasks/worker.jsonl',
|
||||
subagent: { parentSessionId: 'parent-session', agentType: 'worker', status: 'completed' },
|
||||
subagentTranscriptCount: 0
|
||||
})
|
||||
it('passes the complete child and its resolved folder target to resume', async () => {
|
||||
listSubagentSessions.mockResolvedValue({ sessions: [child], issues: [] })
|
||||
const resume = {
|
||||
getState: vi.fn(() => ({
|
||||
blocked: false,
|
||||
worktreeId: 'folder:repo',
|
||||
usesSessionWorktree: true
|
||||
})),
|
||||
onResume: vi.fn()
|
||||
}
|
||||
const { getByRole } = render(
|
||||
<SessionSubagentsSection session={makeSession({ agent: 'omp' })} resume={resume} />
|
||||
)
|
||||
await act(async () => {})
|
||||
fireEvent.click(getByRole('button', { name: 'Resume in Folder' }))
|
||||
expect(resume.getState).toHaveBeenCalledWith(child)
|
||||
expect(resume.onResume).toHaveBeenCalledExactlyOnceWith(child, 'folder:repo')
|
||||
})
|
||||
it.each([
|
||||
{ agent: 'claude' as const },
|
||||
{ sessionId: 'parent-session' },
|
||||
{ sessionId: '' },
|
||||
{ filePath: '' },
|
||||
{ messageCount: 0, previewMessages: [] }
|
||||
])('withholds resume for a non-independent or empty child %j', async (overrides) => {
|
||||
listSubagentSessions.mockResolvedValue({ sessions: [{ ...child, ...overrides }], issues: [] })
|
||||
const resume = { getState: vi.fn(), onResume: vi.fn() }
|
||||
const { queryByRole } = render(
|
||||
<SessionSubagentsSection session={makeSession()} resume={resume} />
|
||||
)
|
||||
await act(async () => {})
|
||||
expect(queryByRole('button', { name: /Resume/ })).toBeNull()
|
||||
expect(resume.getState).not.toHaveBeenCalled()
|
||||
})
|
||||
it('disables resume when the existing target resolver blocks the child host', async () => {
|
||||
listSubagentSessions.mockResolvedValue({ sessions: [child], issues: [] })
|
||||
const resume = {
|
||||
getState: vi.fn(() => ({ blocked: true, worktreeId: null, usesSessionWorktree: false })),
|
||||
onResume: vi.fn()
|
||||
}
|
||||
const { getByRole } = render(
|
||||
<SessionSubagentsSection session={makeSession()} resume={resume} />
|
||||
)
|
||||
await act(async () => {})
|
||||
const button = getByRole('button', { name: 'Resume in New Tab' })
|
||||
expect(button.hasAttribute('disabled')).toBe(true)
|
||||
fireEvent.click(button)
|
||||
expect(resume.onResume).not.toHaveBeenCalled()
|
||||
})
|
||||
})
|
||||
|
||||
describe('nested OMP history', () => {
|
||||
@@ -222,46 +113,6 @@ describe('nested OMP history', () => {
|
||||
}
|
||||
const grandchild = { ...makeSubagent('Research'), agent: 'omp' as const, sessionId: 'research' }
|
||||
|
||||
it('loads only opened branches and targets the grandchild when resuming', async () => {
|
||||
listSubagentSessions
|
||||
.mockResolvedValueOnce({ sessions: [child, makeSubagent('Sibling')], issues: [] })
|
||||
.mockResolvedValueOnce({ sessions: [grandchild], issues: [] })
|
||||
const resume = {
|
||||
getState: vi.fn(() => ({
|
||||
blocked: false,
|
||||
worktreeId: 'folder:repo',
|
||||
usesSessionWorktree: true
|
||||
})),
|
||||
onResume: vi.fn()
|
||||
}
|
||||
const view = render(<SessionSubagentsSection session={parent} resume={resume} />)
|
||||
await act(async () => {})
|
||||
expect(listSubagentSessions).toHaveBeenCalledTimes(1)
|
||||
expect(view.queryByText('Research')).toBeNull()
|
||||
fireEvent.click(view.getByRole('button', { name: 'Subagents (1)' }))
|
||||
await act(async () => {})
|
||||
expect(listSubagentSessions).toHaveBeenLastCalledWith({
|
||||
agent: 'omp',
|
||||
executionHostId: 'local',
|
||||
parentFilePath: child.filePath
|
||||
})
|
||||
expect(view.queryByText('Research')).not.toBeNull()
|
||||
fireEvent.click(view.getAllByRole('button', { name: 'Resume in Folder' })[1])
|
||||
expect(resume.onResume).toHaveBeenCalledExactlyOnceWith(grandchild, 'folder:repo')
|
||||
})
|
||||
|
||||
it('does not show another parent’s rows while its listing is pending', async () => {
|
||||
listSubagentSessions
|
||||
.mockResolvedValueOnce({ sessions: [child], issues: [] })
|
||||
.mockImplementationOnce(() => new Promise(() => {}))
|
||||
const view = render(<SessionSubagentsSection session={parent} />)
|
||||
await act(async () => {})
|
||||
view.rerender(
|
||||
<SessionSubagentsSection session={{ ...parent, filePath: '/tmp/replacement.jsonl' }} />
|
||||
)
|
||||
expect(view.queryByText('Worker')).toBeNull()
|
||||
})
|
||||
|
||||
it('ignores late nested results after collapse and refetches on reopen', async () => {
|
||||
let resolveChild: (value: AiVaultSubagentListResult) => void = () => {}
|
||||
listSubagentSessions
|
||||
@@ -288,79 +139,6 @@ describe('nested OMP history', () => {
|
||||
expect(listSubagentSessions).toHaveBeenCalledTimes(3)
|
||||
})
|
||||
|
||||
it('keeps cyclic and remote children from offering a disclosure', async () => {
|
||||
listSubagentSessions.mockResolvedValueOnce({
|
||||
sessions: [
|
||||
{ ...child, filePath: parent.filePath },
|
||||
{ ...child, id: 'remote', executionHostId: 'ssh:box' }
|
||||
],
|
||||
issues: []
|
||||
})
|
||||
const view = render(<SessionSubagentsSection session={parent} />)
|
||||
await act(async () => {})
|
||||
expect(view.queryByRole('button', { name: 'Subagents (1)' })).toBeNull()
|
||||
expect(listSubagentSessions).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('offers retry for a failed branch listing', async () => {
|
||||
listSubagentSessions
|
||||
.mockResolvedValueOnce({ sessions: [child], issues: [] })
|
||||
.mockRejectedValueOnce(new Error('offline'))
|
||||
.mockResolvedValueOnce({ sessions: [grandchild], issues: [] })
|
||||
const view = render(<SessionSubagentsSection session={parent} />)
|
||||
await act(async () => {})
|
||||
fireEvent.click(view.getByRole('button', { name: 'Subagents (1)' }))
|
||||
await act(async () => {})
|
||||
fireEvent.click(view.getByRole('button', { name: 'Retry' }))
|
||||
await act(async () => {})
|
||||
expect(view.queryByText('Research')).not.toBeNull()
|
||||
})
|
||||
it('retains expanded branches across a virtual row unmount and same-parent rescan', async () => {
|
||||
listSubagentSessions.mockImplementation(async (args) => ({
|
||||
sessions:
|
||||
typeof args === 'object' &&
|
||||
args !== null &&
|
||||
'parentFilePath' in args &&
|
||||
args.parentFilePath === parent.filePath
|
||||
? [child]
|
||||
: [grandchild],
|
||||
issues: []
|
||||
}))
|
||||
const fixture = (visible: boolean, modifiedAt = parent.modifiedAt) => (
|
||||
<SubagentExpansionProvider>
|
||||
{visible ? <SessionSubagentsSection session={{ ...parent, modifiedAt }} /> : null}
|
||||
</SubagentExpansionProvider>
|
||||
)
|
||||
const view = render(fixture(true))
|
||||
await act(async () => {})
|
||||
fireEvent.click(view.getByRole('button', { name: 'Subagents (1)' }))
|
||||
await act(async () => {})
|
||||
view.rerender(fixture(true, '2026-09-14T12:00:00Z'))
|
||||
await act(async () => {})
|
||||
expect(view.queryByText('Research')).not.toBeNull()
|
||||
view.rerender(fixture(false))
|
||||
view.rerender(fixture(true))
|
||||
await act(async () => {})
|
||||
expect(view.queryByText('Research')).not.toBeNull()
|
||||
})
|
||||
|
||||
it('preserves readable rows when the WSL gate reports partial listing issues and allows retry', async () => {
|
||||
listSubagentSessions
|
||||
.mockResolvedValueOnce({
|
||||
sessions: [child],
|
||||
issues: [{ agent: 'omp', path: parent.filePath, message: 'WSL unavailable' }]
|
||||
})
|
||||
.mockResolvedValueOnce({ sessions: [], issues: [] })
|
||||
const view = render(<SessionSubagentsSection session={parent} />)
|
||||
await act(async () => {})
|
||||
expect(view.queryByText('Worker')).not.toBeNull()
|
||||
expect(view.queryByText('Could not load all subagents.')).not.toBeNull()
|
||||
fireEvent.click(view.getByRole('button', { name: 'Retry' }))
|
||||
await act(async () => {})
|
||||
expect(view.queryByText('No subagents found.')).not.toBeNull()
|
||||
expect(view.queryByText('Worker')).toBeNull()
|
||||
})
|
||||
|
||||
it('never accepts a late response from a replaced parent', async () => {
|
||||
let finish: (value: AiVaultSubagentListResult) => void = () => {}
|
||||
listSubagentSessions
|
||||
|
||||
Reference in New Issue
Block a user