diff --git a/test/unit/client/components/fresh-agent/FreshAgentTranscript.test.tsx b/test/unit/client/components/fresh-agent/FreshAgentTranscript.test.tsx
index 473fbf2a0..20c0eefa9 100644
--- a/test/unit/client/components/fresh-agent/FreshAgentTranscript.test.tsx
+++ b/test/unit/client/components/fresh-agent/FreshAgentTranscript.test.tsx
@@ -434,7 +434,7 @@ describe('FreshAgentTranscript', () => {
expect(strips[0]).toHaveTextContent('1 tool used')
})
- it('coalesces consecutive activity-only assistant turns into one live activity strip', () => {
+ it('keeps consecutive activity-only assistant turns separate while marking only the latest live', () => {
render(
{
/>,
)
- expect(screen.getAllByRole('region', { name: 'Activity strip' })).toHaveLength(1)
+ expect(screen.getAllByRole('region', { name: 'Activity strip' })).toHaveLength(3)
expect(screen.getAllByLabelText('running')).toHaveLength(1)
expect(screen.getByText('src/three.ts')).toBeInTheDocument()
- fireEvent.click(screen.getByRole('button', { name: 'Toggle activity details' }))
+ fireEvent.click(screen.getAllByRole('button', { name: 'Toggle activity details' })[2])
expect(screen.getAllByLabelText('running')).toHaveLength(1)
- expect(screen.getAllByLabelText('complete')).toHaveLength(2)
+ fireEvent.click(screen.getAllByRole('button', { name: 'Toggle activity details' })[0])
+ expect(screen.getAllByLabelText('complete').length).toBeGreaterThanOrEqual(1)
})
it('shows the speaker label once for consecutive turns from the same role', () => {
@@ -690,6 +691,39 @@ describe('FreshAgentTranscript', () => {
.toHaveTextContent('1 tool used · 1 file changed')
})
+ it('keeps adjacent activity-only display turns distinct and actionable', () => {
+ const onFork = vi.fn()
+ render(
+ ,
+ )
+
+ expect(screen.getAllByRole('article', { name: 'Assistant transcript turn' })).toHaveLength(2)
+ expect(screen.getAllByRole('region', { name: 'Activity strip' })).toHaveLength(2)
+
+ const forkButtons = screen.getAllByRole('button', { name: 'Fork conversation from here' })
+ fireEvent.click(forkButtons[1])
+ expect(onFork).toHaveBeenCalledWith('display-activity-2')
+ })
+
it('strips system reminders without collapsing older turns', () => {
render(
({
+ copyText: vi.fn().mockResolvedValue(true),
+}))
+
+afterEach(() => cleanup())
+
+function codexDisplayTurn(): FreshAgentTurn {
+ return {
+ id: 'codex-native-turn-1',
+ turnId: 'codex-display:v1:opaque-user-row',
+ role: 'assistant',
+ summary: 'answer',
+ items: [{ id: 'text-1', kind: 'text', text: 'done' }],
+ }
+}
+
+describe('FreshAgentTurnActions', () => {
+ it('passes the opaque display turn id to action callbacks', () => {
+ const onForkFromTurn = vi.fn()
+ const items = buildTurnActionItems(codexDisplayTurn(), {
+ canFork: true,
+ onForkFromTurn,
+ })
+
+ items.find((item) => item.label === 'Fork conversation from here')?.run()
+
+ expect(onForkFromTurn).toHaveBeenCalledWith('codex-display:v1:opaque-user-row')
+ })
+
+ it('uses the display turn id from the hover toolbar', () => {
+ const onForkFromTurn = vi.fn()
+ render(
+ ,
+ )
+
+ fireEvent.click(screen.getByRole('button', { name: 'Fork conversation from here' }))
+
+ expect(onForkFromTurn).toHaveBeenCalledWith('codex-display:v1:opaque-user-row')
+ })
+})
diff --git a/test/unit/client/components/fresh-agent/FreshAgentView.test.tsx b/test/unit/client/components/fresh-agent/FreshAgentView.test.tsx
index 33ec6b75b..761734179 100644
--- a/test/unit/client/components/fresh-agent/FreshAgentView.test.tsx
+++ b/test/unit/client/components/fresh-agent/FreshAgentView.test.tsx
@@ -156,6 +156,28 @@ function createDeferred() {
return { promise, resolve, reject }
}
+function freshopencodeSnapshot(text: string, revision: number) {
+ return {
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ threadId: 'ses_late_change',
+ sessionId: 'ses_late_change',
+ status: 'idle',
+ latestTurnId: 'msg_assistant_1',
+ revision,
+ summary: 'OpenCode done',
+ capabilities: { send: true, interrupt: true, fork: true },
+ pendingApprovals: [],
+ pendingQuestions: [],
+ diffs: [],
+ worktrees: [],
+ turns: [
+ { id: 'msg_user_1', turnId: 'msg_user_1', role: 'user', summary: 'go', items: [{ id: 'user-text', kind: 'text', text: 'go' }] },
+ { id: 'msg_assistant_1', turnId: 'msg_assistant_1', role: 'assistant', summary: text, items: [{ id: 'assistant-text', kind: 'text', text }] },
+ ],
+ }
+}
+
beforeEach(() => {
wsMock.send.mockReset()
wsMock.onMessage.mockReset()
@@ -374,6 +396,31 @@ describe('FreshAgentView', () => {
expect(root).toHaveClass('fresh-agent-style-serif')
})
+ it('applies the mono terminal style to the view root', async () => {
+ const store = createStore()
+ render(
+
+
+ ,
+ )
+
+ const root = await waitFor(() => document.querySelector('[data-context="fresh-agent"]') as HTMLElement)
+ expect(root).toHaveAttribute('data-style', 'mono')
+ expect(root).toHaveClass('fresh-agent-style-mono')
+ })
+
it('exposes a durable sessionRef as the fresh-agent context session id', async () => {
const store = createStore()
render(
@@ -561,6 +608,7 @@ describe('FreshAgentView', () => {
provider: 'codex',
createRequestId: 'req-restored-codex',
sessionRef: { provider: 'codex', sessionId: 'thread-from-ref' },
+ initialCwd: '/repo/from-ref',
status: 'connected',
}}
/>
@@ -568,7 +616,12 @@ describe('FreshAgentView', () => {
)
await waitFor(() => {
- expect(apiMock.getFreshAgentThreadSnapshot).toHaveBeenCalledWith('freshcodex', 'codex', 'thread-from-ref', expect.any(Object))
+ expect(apiMock.getFreshAgentThreadSnapshot).toHaveBeenCalledWith(
+ 'freshcodex',
+ 'codex',
+ 'thread-from-ref',
+ expect.objectContaining({ cwd: '/repo/from-ref' }),
+ )
})
expect(await screen.findByText('Codex turn')).toBeInTheDocument()
})
@@ -1147,8 +1200,9 @@ describe('FreshAgentView', () => {
})
fireEvent.click(screen.getByRole('button', { name: 'Send' }))
- expect(wsMock.send).toHaveBeenCalledWith({
+ expect(wsMock.send).toHaveBeenCalledWith(expect.objectContaining({
type: 'freshAgent.send',
+ requestId: expect.any(String),
sessionId: 'thread-1',
sessionType: 'freshcodex',
provider: 'codex',
@@ -1158,12 +1212,134 @@ describe('FreshAgentView', () => {
model: 'gpt-5.3-codex-spark',
effort: 'max',
},
- })
+ }))
expect(screen.queryByRole('button', { name: 'Interrupt' })).not.toBeInTheDocument()
expect(screen.queryByRole('button', { name: 'Fork' })).not.toBeInTheDocument()
})
+ it('uses send acknowledgements to patch checkpoints and clear local echo only on the submitted user display turn', async () => {
+ const store = createStore()
+ const checkpoint = createDeferred<{ id: string; ts: number; label: string; requestId: string }>()
+ let onMessage: ((message: Record) => void) | undefined
+ wsMock.onMessage.mockImplementation((handler: (message: Record) => void) => {
+ onMessage = handler
+ return () => {}
+ })
+ apiMock.getFreshAgentThreadSnapshot
+ .mockResolvedValueOnce({
+ status: 'idle',
+ summary: 'empty',
+ capabilities: { send: true, interrupt: true, fork: true },
+ turns: [],
+ })
+ .mockResolvedValueOnce({
+ status: 'idle',
+ summary: 'answered',
+ capabilities: { send: true, interrupt: true, fork: true },
+ turns: [
+ {
+ id: 'native-user-turn',
+ turnId: 'display-user-1',
+ role: 'user',
+ summary: 'Ship it',
+ items: [{ id: 'user-text-1', kind: 'text', text: 'Ship it' }],
+ },
+ {
+ id: 'native-assistant-turn',
+ turnId: 'display-assistant-1',
+ role: 'assistant',
+ summary: 'Done',
+ items: [{ id: 'assistant-text-1', kind: 'text', text: 'Done.' }],
+ },
+ ],
+ })
+ apiMock.post.mockImplementation((url: string, body: Record) => {
+ if (url === '/api/fresh-agent/checkpoints') return checkpoint.promise
+ if (url === '/api/fresh-agent/checkpoints/metadata') return Promise.resolve({ ok: true, body })
+ return Promise.resolve({ title: null, source: 'none' })
+ })
+ store.dispatch(initLayout({
+ tabId: 'tab-1',
+ paneId: 'pane-1',
+ content: {
+ kind: 'fresh-agent',
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ createRequestId: 'req-normalized-send',
+ sessionId: 'thread-normalized-send',
+ status: 'idle',
+ initialCwd: '/repo',
+ },
+ }))
+
+ render(
+
+
+ ,
+ )
+
+ await waitFor(() => {
+ expect(screen.getByRole('textbox', { name: 'Chat message input' })).not.toBeDisabled()
+ })
+ wsMock.send.mockClear()
+
+ fireEvent.change(screen.getByRole('textbox', { name: 'Chat message input' }), {
+ target: { value: 'Ship it' },
+ })
+ fireEvent.click(screen.getByRole('button', { name: 'Send' }))
+
+ const send = sentFreshAgentMessages('freshAgent.send').at(-1)
+ expect(send).toMatchObject({
+ type: 'freshAgent.send',
+ sessionId: 'thread-normalized-send',
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ text: 'Ship it',
+ })
+ expect(send?.requestId).toEqual(expect.any(String))
+ const requestId = String(send?.requestId)
+ expect(apiMock.post).toHaveBeenCalledWith('/api/fresh-agent/checkpoints', {
+ cwd: '/repo',
+ label: 'Ship it',
+ requestId,
+ })
+ expect(screen.getByText('Ship it')).toBeInTheDocument()
+
+ expect(onMessage).toBeTypeOf('function')
+ act(() => {
+ onMessage?.({
+ type: 'freshAgent.send.accepted',
+ requestId,
+ submittedTurnId: 'display-user-1',
+ })
+ })
+ await act(async () => {
+ checkpoint.resolve({
+ id: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ ts: 1,
+ label: 'Ship it',
+ requestId,
+ })
+ await Promise.resolve()
+ })
+
+ await waitFor(() => {
+ expect(apiMock.post).toHaveBeenCalledWith('/api/fresh-agent/checkpoints/metadata', {
+ cwd: '/repo',
+ id: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ requestId,
+ turnId: 'display-user-1',
+ })
+ })
+ await waitFor(() => {
+ expect(screen.getByText('Done.')).toBeInTheDocument()
+ })
+ expect(screen.getAllByText('Ship it')).toHaveLength(1)
+ const transcriptTurns = screen.getAllByRole('article')
+ expect(transcriptTurns.at(-1)).toHaveTextContent('Done.')
+ })
+
it('does not transmit stale Freshopencode permissionMode on create or send', async () => {
const creatingStore = createStore()
creatingStore.dispatch(initLayout({
@@ -1231,8 +1407,9 @@ describe('FreshAgentView', () => {
})
fireEvent.click(screen.getByRole('button', { name: 'Send' }))
- expect(wsMock.send).toHaveBeenCalledWith({
+ expect(wsMock.send).toHaveBeenCalledWith(expect.objectContaining({
type: 'freshAgent.send',
+ requestId: expect.any(String),
sessionId: 'freshopencode-req-opencode-send-policy',
sessionType: 'freshopencode',
provider: 'opencode',
@@ -1242,7 +1419,7 @@ describe('FreshAgentView', () => {
model: 'opencode-go/deepseek-v4-flash',
effort: 'max',
},
- })
+ }))
})
it('auto-titles the fresh-agent pane and tab from the first user message', async () => {
@@ -2047,12 +2224,19 @@ describe('FreshAgentView', () => {
target: { value: 'New user request' },
})
fireEvent.click(screen.getByRole('button', { name: 'Send' }))
+ const send = sentFreshAgentMessages('freshAgent.send').at(-1)
+ const requestId = String(send?.requestId)
expect(screen.getByText('Older user request')).toBeInTheDocument()
expect(screen.getByText('Older assistant answer')).toBeInTheDocument()
expect(onMessage).toBeTypeOf('function')
act(() => {
+ onMessage?.({
+ type: 'freshAgent.send.accepted',
+ requestId,
+ submittedTurnId: 'turn-new-user',
+ })
onMessage?.({
type: 'freshAgent.event',
sessionId: 'thread-partial-refresh',
@@ -2745,6 +2929,45 @@ describe('FreshAgentView', () => {
})
})
+ it('lets a Freshcodex pane choose the mono terminal style', async () => {
+ const store = createStore()
+ store.dispatch(initLayout({
+ tabId: 'tab-1',
+ paneId: 'pane-1',
+ content: {
+ kind: 'fresh-agent',
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ createRequestId: 'req-mono-style',
+ sessionId: 'thread-mono-style',
+ status: 'idle',
+ style: 'sans',
+ },
+ }))
+
+ render(
+
+
+ ,
+ )
+
+ fireEvent.click(screen.getByRole('button', { name: 'Agent settings' }))
+ const styleSelect = screen.getByRole('combobox', { name: 'Style' })
+ expect(Array.from(styleSelect.querySelectorAll('option')).map((option) => option.textContent)).toEqual(['Sans', 'Serif', 'Mono'])
+
+ fireEvent.change(styleSelect, { target: { value: 'mono' } })
+
+ const layout = store.getState().panes.layouts['tab-1']
+ expect(layout?.type === 'leaf' && layout.content.kind === 'fresh-agent' ? layout.content.style : null).toBe('mono')
+ expect(saveServerSettingsPatchSpy).toHaveBeenCalledWith({
+ freshAgent: {
+ providers: {
+ freshcodex: { style: 'mono' },
+ },
+ },
+ })
+ })
+
it('lets Freshopencode settings choose model and thinking controls from the gear popover', async () => {
const store = createStore()
store.dispatch(initLayout({
@@ -2878,6 +3101,67 @@ describe('FreshAgentView', () => {
expect(store.getState().panes.refreshRequestsByPane?.['tab-1']?.['pane-1']).toBeUndefined()
})
+ it('refreshes freshopencode on session.changed without reopening the bouncer', async () => {
+ const store = createStore()
+ let wsHandler: ((message: any) => void) | undefined
+ wsMock.onMessage.mockImplementation((handler) => {
+ wsHandler = handler
+ return () => {}
+ })
+
+ apiMock.getFreshAgentThreadSnapshot
+ .mockResolvedValueOnce(freshopencodeSnapshot('done', 10))
+ .mockResolvedValueOnce(freshopencodeSnapshot('done updated', 11))
+
+ store.dispatch(initLayout({
+ tabId: 'tab-1',
+ paneId: 'pane-1',
+ content: {
+ kind: 'fresh-agent',
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ createRequestId: 'req-late-change',
+ sessionId: 'ses_late_change',
+ sessionRef: { provider: 'opencode', sessionId: 'ses_late_change' },
+ resumeSessionId: 'ses_late_change',
+ status: 'idle',
+ },
+ }))
+
+ render(
+
+
+ ,
+ )
+
+ await waitFor(() => {
+ expect(screen.getByText('done')).toBeInTheDocument()
+ })
+
+ act(() => {
+ wsHandler?.({
+ type: 'freshAgent.event',
+ sessionId: 'ses_late_change',
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ event: {
+ type: 'freshAgent.session.changed',
+ sessionId: 'ses_late_change',
+ reason: 'opencode-message',
+ },
+ })
+ })
+
+ await waitFor(() => {
+ expect(screen.getByText('done updated')).toBeInTheDocument()
+ })
+ expect(apiMock.getFreshAgentThreadSnapshot).toHaveBeenCalledTimes(2)
+ expect(getFreshAgentPaneContent(store)).toMatchObject({
+ sessionId: 'ses_late_change',
+ status: 'idle',
+ })
+ })
+
it('normalizes obsolete Freshcodex models to the default radio option', async () => {
const store = createStore()
render(
diff --git a/test/unit/client/hooks/useElectronExternalLinks.test.tsx b/test/unit/client/hooks/useElectronExternalLinks.test.tsx
new file mode 100644
index 000000000..4dcb8f2c2
--- /dev/null
+++ b/test/unit/client/hooks/useElectronExternalLinks.test.tsx
@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { render, cleanup } from '@testing-library/react'
+import { useElectronExternalLinks } from '@/hooks/useElectronExternalLinks'
+
+const openExternalUrlMock = vi.hoisted(() => vi.fn())
+
+vi.mock('@/lib/open-url', () => ({
+ openExternalUrl: openExternalUrlMock,
+ shouldOpenLinkExternally: (event: MouseEvent) => event.ctrlKey || event.shiftKey,
+}))
+
+function TestHarness() {
+ useElectronExternalLinks()
+ return link
+}
+
+describe('useElectronExternalLinks', () => {
+ beforeEach(() => {
+ cleanup()
+ openExternalUrlMock.mockClear()
+ })
+
+ afterEach(() => {
+ cleanup()
+ vi.unstubAllGlobals()
+ })
+
+ it('does nothing in a normal browser', () => {
+ vi.stubGlobal('freshellDesktop', undefined)
+ const addEventListenerSpy = vi.spyOn(document, 'addEventListener')
+ const { container } = render()
+ const link = container.querySelector('a')!
+ const clickEvent = new MouseEvent('click', { ctrlKey: true, bubbles: true })
+
+ link.dispatchEvent(clickEvent)
+
+ expect(addEventListenerSpy).not.toHaveBeenCalledWith('click', expect.any(Function), true)
+ expect(openExternalUrlMock).not.toHaveBeenCalled()
+ addEventListenerSpy.mockRestore()
+ })
+
+ it('opens external https links on ctrl+click in Electron', () => {
+ vi.stubGlobal('freshellDesktop', { isElectron: true })
+ const { container } = render()
+ const link = container.querySelector('a')!
+ const clickEvent = new MouseEvent('click', { ctrlKey: true, bubbles: true })
+
+ link.dispatchEvent(clickEvent)
+
+ expect(openExternalUrlMock).toHaveBeenCalledWith('https://example.com/')
+ })
+
+ it('opens external https links on shift+click in Electron', () => {
+ vi.stubGlobal('freshellDesktop', { isElectron: true })
+ const { container } = render()
+ const link = container.querySelector('a')!
+ const clickEvent = new MouseEvent('click', { shiftKey: true, bubbles: true })
+
+ link.dispatchEvent(clickEvent)
+
+ expect(openExternalUrlMock).toHaveBeenCalledWith('https://example.com/')
+ })
+
+ it('ignores plain left-clicks in Electron', () => {
+ vi.stubGlobal('freshellDesktop', { isElectron: true })
+ const { container } = render()
+ const link = container.querySelector('a')!
+ const clickEvent = new MouseEvent('click', { bubbles: true })
+
+ link.dispatchEvent(clickEvent)
+
+ expect(openExternalUrlMock).not.toHaveBeenCalled()
+ })
+
+ it('ignores non-http anchors in Electron', () => {
+ vi.stubGlobal('freshellDesktop', { isElectron: true })
+ function TestHarnessWithMail() {
+ useElectronExternalLinks()
+ return email
+ }
+ const { container } = render()
+ const link = container.querySelector('a')!
+ const clickEvent = new MouseEvent('click', { ctrlKey: true, bubbles: true })
+
+ link.dispatchEvent(clickEvent)
+
+ expect(openExternalUrlMock).not.toHaveBeenCalled()
+ })
+})
diff --git a/test/unit/client/lib/api.test.ts b/test/unit/client/lib/api.test.ts
index 9d22c1cb2..f0dd24bb1 100644
--- a/test/unit/client/lib/api.test.ts
+++ b/test/unit/client/lib/api.test.ts
@@ -220,23 +220,23 @@ describe('visible-first read-model helpers', () => {
.mockResolvedValueOnce(mockJson(codexContractTurnPage))
.mockResolvedValueOnce(mockJson(codexContractTurnBody))
- await getFreshAgentThreadSnapshot('freshcodex', 'codex', 'thread-1', { revision: 7, signal })
- await getFreshAgentTurnPage('freshcodex', 'codex', 'thread-1', { revision: 7, cursor: 'cursor-1', limit: 20 }, { signal })
- await getFreshAgentTurnBody('freshcodex', 'codex', 'thread-1', 'turn-1', { revision: 7, signal })
+ await getFreshAgentThreadSnapshot('freshcodex', 'codex', 'thread-1', { revision: 7, cwd: '/repo/worktree', signal })
+ await getFreshAgentTurnPage('freshcodex', 'codex', 'thread-1', { revision: 7, cursor: 'cursor-1', cwd: '/repo/worktree', limit: 20 }, { signal })
+ await getFreshAgentTurnBody('freshcodex', 'codex', 'thread-1', 'turn-1', { revision: 7, cwd: '/repo/worktree', signal })
expect(mockFetch).toHaveBeenNthCalledWith(
1,
- '/api/fresh-agent/threads/freshcodex/codex/thread-1?revision=7',
+ '/api/fresh-agent/threads/freshcodex/codex/thread-1?revision=7&cwd=%2Frepo%2Fworktree',
expect.objectContaining({ signal, headers: expect.any(Headers) }),
)
expect(mockFetch).toHaveBeenNthCalledWith(
2,
- '/api/fresh-agent/threads/freshcodex/codex/thread-1/turns?revision=7&cursor=cursor-1&limit=20',
+ '/api/fresh-agent/threads/freshcodex/codex/thread-1/turns?revision=7&cursor=cursor-1&cwd=%2Frepo%2Fworktree&limit=20',
expect.objectContaining({ signal, headers: expect.any(Headers) }),
)
expect(mockFetch).toHaveBeenNthCalledWith(
3,
- '/api/fresh-agent/threads/freshcodex/codex/thread-1/turns/turn-1?revision=7',
+ '/api/fresh-agent/threads/freshcodex/codex/thread-1/turns/turn-1?revision=7&cwd=%2Frepo%2Fworktree',
expect.objectContaining({ signal, headers: expect.any(Headers) }),
)
})
diff --git a/test/unit/client/lib/fresh-agent-checkpoints.test.ts b/test/unit/client/lib/fresh-agent-checkpoints.test.ts
index 07adf1f43..7af9e930c 100644
--- a/test/unit/client/lib/fresh-agent-checkpoints.test.ts
+++ b/test/unit/client/lib/fresh-agent-checkpoints.test.ts
@@ -6,10 +6,10 @@ import {
} from '@/lib/fresh-agent-checkpoints'
import type { FreshAgentTurn } from '@shared/fresh-agent-contract'
-function userTurn(id: string, text: string): FreshAgentTurn {
+function userTurn(id: string, text: string, turnId = id): FreshAgentTurn {
return {
id,
- turnId: id,
+ turnId,
role: 'user',
summary: text,
items: [{ id: `${id}-item`, kind: 'text', text }],
@@ -42,6 +42,82 @@ describe('checkpointLabelForText', () => {
})
describe('pickCheckpointForTurn', () => {
+ it('matches persisted display turn id only for normalized user turns', () => {
+ const user = userTurn('native-turn-1-user', 'same native', 'display-user-1')
+ const assistant = {
+ ...assistantTurn('native-turn-1-assistant'),
+ turnId: 'display-assistant-1',
+ id: 'native-turn-1-assistant',
+ summary: 'same native',
+ items: [{ id: 'assistant-item', kind: 'text' as const, text: 'same native' }],
+ } as FreshAgentTurn
+ const checkpoints: CheckpointEntry[] = [
+ { id: 'sha-user', ts: 1, label: 'same native', turnId: 'display-user-1' },
+ ]
+
+ expect(pickCheckpointForTurn(checkpoints, [user, assistant], user)?.id).toBe('sha-user')
+ expect(pickCheckpointForTurn(checkpoints, [user, assistant], assistant)).toBeNull()
+ })
+
+ it('prefers display turn id and request id before duplicate label ordinal matching', () => {
+ const older = userTurn('old-native', 'fix the bug', 'display-old')
+ const newer = userTurn('new-native', 'fix the bug', 'display-new') as FreshAgentTurn & { requestId: string }
+ newer.requestId = 'send-new'
+ const turns = [newer, assistantTurn('reply'), older]
+ const checkpoints: CheckpointEntry[] = [
+ { id: 'sha-old', ts: 100, label: 'fix the bug', turnId: 'display-old', requestId: 'send-old' },
+ { id: 'sha-new', ts: 200, label: 'fix the bug', requestId: 'send-new' },
+ ]
+
+ expect(pickCheckpointForTurn(checkpoints, turns, newer)?.id).toBe('sha-new')
+ expect(pickCheckpointForTurn(checkpoints, turns, older)?.id).toBe('sha-old')
+ })
+
+ it('does not let a checkpoint for an older duplicate prompt satisfy a newer display turn by label', () => {
+ const newer = userTurn('new-native', 'fix the bug', 'display-new')
+ const older = userTurn('old-native', 'fix the bug', 'display-old')
+ const checkpoints: CheckpointEntry[] = [
+ { id: 'sha-old', ts: 100, label: 'fix the bug', turnId: 'display-old', requestId: 'send-old' },
+ ]
+
+ expect(pickCheckpointForTurn(checkpoints, [newer, older], newer)).toBeNull()
+ })
+
+ it('does not count direct-id checkpoints when indexing legacy label-only matches', () => {
+ const older = userTurn('old-native', 'fix the bug', 'display-old')
+ const newer = userTurn('new-native', 'fix the bug', 'display-new')
+ const checkpoints: CheckpointEntry[] = [
+ { id: 'sha-new', ts: 200, label: 'fix the bug' },
+ { id: 'sha-old', ts: 100, label: 'fix the bug', turnId: 'display-old' },
+ ]
+
+ expect(pickCheckpointForTurn(checkpoints, [older, newer], newer)?.id).toBe('sha-new')
+ })
+
+ it('uses label ordinal matching when saved submitted display ids no longer resolve after restart', () => {
+ const older = userTurn('old-native', 'fix the bug', 'display-old-after-restart')
+ const newer = userTurn('new-native', 'fix the bug', 'display-new-after-restart')
+ const checkpoints: CheckpointEntry[] = [
+ {
+ id: 'sha-new',
+ ts: 200,
+ label: 'fix the bug',
+ turnId: 'submitted-new-before-restart',
+ requestId: 'send-new',
+ },
+ {
+ id: 'sha-old',
+ ts: 100,
+ label: 'fix the bug',
+ turnId: 'submitted-old-before-restart',
+ requestId: 'send-old',
+ },
+ ]
+
+ expect(pickCheckpointForTurn(checkpoints, [older, newer], older)?.id).toBe('sha-old')
+ expect(pickCheckpointForTurn(checkpoints, [older, newer], newer)?.id).toBe('sha-new')
+ })
+
it('matches a user turn to its checkpoint by label', () => {
const turns = [userTurn('t1', 'add a test'), assistantTurn('t2')]
expect(pickCheckpointForTurn(CHECKPOINTS, turns, turns[0])?.id).toBe('sha-2')
diff --git a/test/unit/client/lib/fresh-agent-ws.test.ts b/test/unit/client/lib/fresh-agent-ws.test.ts
index 4838a8a0b..20bdc1a4e 100644
--- a/test/unit/client/lib/fresh-agent-ws.test.ts
+++ b/test/unit/client/lib/fresh-agent-ws.test.ts
@@ -225,6 +225,44 @@ describe('fresh-agent-ws', () => {
expect(store.getState().freshAgent.sessions[key]).toBeUndefined()
})
+ it('handles freshAgent.session.changed without mutating idle status', () => {
+ const store = createFreshAgentStore()
+ const sessionId = 'ses_opencode_idle'
+ const key = `freshopencode:opencode:${sessionId}`
+
+ expect(handleFreshAgentMessage(store.dispatch, {
+ type: 'freshAgent.event',
+ sessionId,
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ event: {
+ type: 'freshAgent.session.snapshot',
+ sessionId,
+ latestTurnId: 'msg_assistant_1',
+ status: 'idle',
+ revision: 11,
+ },
+ })).toBe(true)
+
+ expect(handleFreshAgentMessage(store.dispatch, {
+ type: 'freshAgent.event',
+ sessionId,
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ event: {
+ type: 'freshAgent.session.changed',
+ sessionId,
+ reason: 'opencode-message',
+ },
+ })).toBe(true)
+
+ expect(store.getState().freshAgent.sessions[key]).toMatchObject({
+ status: 'idle',
+ latestTurnId: 'msg_assistant_1',
+ historyRevision: 11,
+ })
+ })
+
it('does not let delayed metadata downgrade newer snapshot identity', () => {
const store = createFreshAgentStore()
const sessionId = 'claude-thread-metadata-order'
diff --git a/test/unit/client/lib/open-url.test.ts b/test/unit/client/lib/open-url.test.ts
new file mode 100644
index 000000000..a30b2830d
--- /dev/null
+++ b/test/unit/client/lib/open-url.test.ts
@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { openExternalUrl } from '@/lib/open-url'
+
+describe('openExternalUrl', () => {
+ let windowOpenSpy: ReturnType
+
+ beforeEach(() => {
+ windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null)
+ })
+
+ afterEach(() => {
+ windowOpenSpy.mockRestore()
+ vi.unstubAllGlobals()
+ })
+
+ it('uses window.freshellDesktop.openExternal when available', () => {
+ const openExternal = vi.fn().mockResolvedValue(undefined)
+ vi.stubGlobal('freshellDesktop', { openExternal, isElectron: true })
+
+ openExternalUrl('https://example.com')
+
+ expect(openExternal).toHaveBeenCalledWith('https://example.com')
+ expect(windowOpenSpy).not.toHaveBeenCalled()
+ })
+
+ it('falls back to window.open when freshellDesktop is unavailable', () => {
+ vi.stubGlobal('freshellDesktop', undefined)
+
+ openExternalUrl('https://example.com')
+
+ expect(windowOpenSpy).toHaveBeenCalledWith('https://example.com', '_blank', 'noopener,noreferrer')
+ })
+
+ it('falls back to window.open when freshellDesktop.openExternal is not a function', () => {
+ vi.stubGlobal('freshellDesktop', { isElectron: true })
+
+ openExternalUrl('https://example.com')
+
+ expect(windowOpenSpy).toHaveBeenCalledWith('https://example.com', '_blank', 'noopener,noreferrer')
+ })
+
+ it('resolves relative URLs against window.location when using openExternal', () => {
+ const openExternal = vi.fn().mockResolvedValue(undefined)
+ vi.stubGlobal('freshellDesktop', { openExternal, isElectron: true })
+ vi.stubGlobal('location', { href: 'https://freshell.example.com:3001/pane/tab-1' })
+
+ openExternalUrl('/api/proxy/http/8080/')
+
+ expect(openExternal).toHaveBeenCalledWith('https://freshell.example.com:3001/api/proxy/http/8080/')
+ })
+
+ it('resolves relative URLs against window.location when falling back to window.open', () => {
+ vi.stubGlobal('freshellDesktop', undefined)
+ vi.stubGlobal('location', { href: 'https://freshell.example.com:3001/' })
+
+ openExternalUrl('/api/proxy/http/8080/')
+
+ expect(windowOpenSpy).toHaveBeenCalledWith('https://freshell.example.com:3001/api/proxy/http/8080/', '_blank', 'noopener,noreferrer')
+ })
+
+ it('logs a warning but does not throw when openExternal rejects', async () => {
+ const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ const openExternal = vi.fn().mockRejectedValue(new Error('OS refused'))
+ vi.stubGlobal('freshellDesktop', { openExternal, isElectron: true })
+
+ openExternalUrl('https://example.com')
+
+ // Wait for the promise rejection to be caught.
+ await new Promise((resolve) => setTimeout(resolve, 0))
+
+ expect(openExternal).toHaveBeenCalledWith('https://example.com')
+ expect(consoleWarnSpy).toHaveBeenCalledWith(
+ 'Failed to open external URL via Electron:',
+ 'https://example.com',
+ expect.any(Error),
+ )
+ consoleWarnSpy.mockRestore()
+ })
+
+ it('ignores non-string URLs', () => {
+ vi.stubGlobal('freshellDesktop', undefined)
+
+ openExternalUrl(undefined as unknown as string)
+
+ expect(windowOpenSpy).not.toHaveBeenCalled()
+ })
+})
diff --git a/test/unit/electron/external-url.test.ts b/test/unit/electron/external-url.test.ts
new file mode 100644
index 000000000..c8ff957ee
--- /dev/null
+++ b/test/unit/electron/external-url.test.ts
@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { registerOpenExternalHandler, type ExternalUrlDeps } from '../../../electron/external-url.js'
+
+describe('registerOpenExternalHandler', () => {
+ let deps: ExternalUrlDeps
+ let handler: (event: { sender?: { id?: number } }, url: string) => Promise
+
+ beforeEach(() => {
+ deps = {
+ ipcMain: {
+ handle: vi.fn((channel: string, fn: (event: { sender?: { id?: number } }, url: string) => Promise) => {
+ if (channel === 'open-external-url') {
+ handler = fn
+ }
+ }),
+ },
+ shell: {
+ openExternal: vi.fn().mockResolvedValue(undefined),
+ },
+ isAllowedSender: (event) => event.sender?.id === 42,
+ }
+ registerOpenExternalHandler(deps)
+ })
+
+ it('registers open-external-url IPC handler', () => {
+ expect(deps.ipcMain.handle).toHaveBeenCalledWith('open-external-url', expect.any(Function))
+ })
+
+ it('opens https URLs with shell.openExternal', async () => {
+ await handler({ sender: { id: 42 } }, 'https://example.com')
+ expect(deps.shell.openExternal).toHaveBeenCalledWith('https://example.com/')
+ })
+
+ it('opens http URLs with shell.openExternal', async () => {
+ await handler({ sender: { id: 42 } }, 'http://example.com')
+ expect(deps.shell.openExternal).toHaveBeenCalledWith('http://example.com/')
+ })
+
+ it('canonicalizes an https URL with a path and query', async () => {
+ await handler({ sender: { id: 42 } }, 'https://example.com/foo?bar=1')
+ expect(deps.shell.openExternal).toHaveBeenCalledWith('https://example.com/foo?bar=1')
+ })
+
+ it('rejects requests from disallowed senders', async () => {
+ await expect(handler({ sender: { id: 99 } }, 'https://example.com')).rejects.toThrow(/sender not allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects requests when sender id is missing', async () => {
+ await expect(handler({}, 'https://example.com')).rejects.toThrow(/sender not allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects non-string URLs', async () => {
+ await expect(handler({ sender: { id: 42 } }, undefined as unknown as string)).rejects.toThrow(/canonical absolute http\/https URLs are allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects file: URLs', async () => {
+ await expect(handler({ sender: { id: 42 } }, 'file:///etc/passwd')).rejects.toThrow(/canonical absolute http\/https URLs are allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects javascript: URLs', async () => {
+ await expect(handler({ sender: { id: 42 } }, 'javascript:alert(1)')).rejects.toThrow(/canonical absolute http\/https URLs are allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects relative URLs', async () => {
+ await expect(handler({ sender: { id: 42 } }, '/api/proxy/http/8080/')).rejects.toThrow(/canonical absolute http\/https URLs are allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects URLs containing control characters', async () => {
+ await expect(handler({ sender: { id: 42 } }, 'https://example.com\n/evil')).rejects.toThrow(/canonical absolute http\/https URLs are allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+
+ it('rejects URLs with embedded credentials', async () => {
+ await expect(handler({ sender: { id: 42 } }, 'https://user:pass@example.com/')).rejects.toThrow(/canonical absolute http\/https URLs are allowed/)
+ expect(deps.shell.openExternal).not.toHaveBeenCalled()
+ })
+})
diff --git a/test/unit/electron/preload.test.ts b/test/unit/electron/preload.test.ts
index f3304e348..d12fbc771 100644
--- a/test/unit/electron/preload.test.ts
+++ b/test/unit/electron/preload.test.ts
@@ -43,6 +43,7 @@ describe('Preload API', () => {
'isElectron',
'onUpdateAvailable',
'onUpdateDownloaded',
+ 'openExternal',
'platform',
'setGlobalHotkey',
])
@@ -62,6 +63,7 @@ describe('Preload API', () => {
expect(typeof exposedApi.completeSetup).toBe('function')
expect(typeof exposedApi.getLaunchOptions).toBe('function')
expect(typeof exposedApi.chooseLaunchOption).toBe('function')
+ expect(typeof exposedApi.openExternal).toBe('function')
})
it('getServerMode invokes correct IPC channel', () => {
@@ -108,4 +110,9 @@ describe('Preload API', () => {
exposedApi.chooseLaunchOption(choice)
expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('choose-launch-option', choice)
})
+
+ it('openExternal invokes correct IPC channel with URL', () => {
+ exposedApi.openExternal('https://example.com')
+ expect(mockIpcRenderer.invoke).toHaveBeenCalledWith('open-external-url', 'https://example.com')
+ })
})
diff --git a/test/unit/server/config-store.test.ts b/test/unit/server/config-store.test.ts
index e991bf9f5..fd4081678 100644
--- a/test/unit/server/config-store.test.ts
+++ b/test/unit/server/config-store.test.ts
@@ -90,6 +90,21 @@ describe('ConfigStore', () => {
expect(exists).toBe(true)
})
+ it('generates and persists the Codex display-id secret without exposing it in settings', async () => {
+ const store = new ConfigStore()
+
+ const secret = await store.getCodexDisplayIdSecret()
+ const settings = await store.getSettings()
+ const saved = JSON.parse(await fsp.readFile(configPath, 'utf-8'))
+ const reloaded = new ConfigStore()
+
+ expect(secret).toEqual(expect.any(String))
+ expect(secret.length).toBeGreaterThanOrEqual(32)
+ expect(saved.serverSecrets.codexDisplayIdSecret).toBe(secret)
+ expect(JSON.stringify(settings)).not.toContain(secret)
+ await expect(reloaded.getCodexDisplayIdSecret()).resolves.toBe(secret)
+ })
+
it('creates .freshell directory if needed', async () => {
const store = new ConfigStore()
await store.load()
diff --git a/test/unit/server/fresh-agent/claude-normalize.test.ts b/test/unit/server/fresh-agent/claude-normalize.test.ts
index ca7333e52..30255f2ed 100644
--- a/test/unit/server/fresh-agent/claude-normalize.test.ts
+++ b/test/unit/server/fresh-agent/claude-normalize.test.ts
@@ -43,4 +43,54 @@ describe('Claude fresh-agent normalization', () => {
costUsd: 1.25,
})
})
+
+ it('keeps user and assistant messages as separate display turns with their native turnIds', () => {
+ const snapshot = normalizeClaudeThreadSnapshot({
+ threadId: 'sdk-claude-invariant',
+ resolved: {
+ kind: 'resolved',
+ queryId: 'sdk-claude-invariant',
+ liveSessionId: 'sdk-claude-invariant',
+ timelineSessionId: '00000000-0000-4000-8000-000000000222',
+ readiness: 'merged',
+ revision: 2,
+ latestTurnId: 'turn:assistant-1',
+ turns: [
+ {
+ sessionId: '00000000-0000-4000-8000-000000000222',
+ turnId: 'turn:user-1',
+ messageId: 'user-1',
+ ordinal: 0,
+ source: 'durable',
+ message: {
+ role: 'user',
+ content: [{ type: 'text', text: 'Inspect the config.' }],
+ timestamp: '2026-04-18T12:00:00.000Z',
+ messageId: 'user-1',
+ },
+ },
+ {
+ sessionId: '00000000-0000-4000-8000-000000000222',
+ turnId: 'turn:assistant-1',
+ messageId: 'assistant-1',
+ ordinal: 1,
+ source: 'durable',
+ message: {
+ role: 'assistant',
+ content: [{ type: 'text', text: 'Inspecting the config now.' }],
+ timestamp: '2026-04-18T12:00:01.000Z',
+ messageId: 'assistant-1',
+ },
+ },
+ ],
+ },
+ status: 'running',
+ })
+
+ expect(snapshot.turns).toHaveLength(2)
+ expect(snapshot.turns).toMatchObject([
+ { turnId: 'turn:user-1', messageId: 'user-1', role: 'user', summary: 'Inspect the config.' },
+ { turnId: 'turn:assistant-1', messageId: 'assistant-1', role: 'assistant', summary: 'Inspecting the config now.' },
+ ])
+ })
})
diff --git a/test/unit/server/fresh-agent/codex-adapter.test.ts b/test/unit/server/fresh-agent/codex-adapter.test.ts
index f2a3d79b6..f2307ed8d 100644
--- a/test/unit/server/fresh-agent/codex-adapter.test.ts
+++ b/test/unit/server/fresh-agent/codex-adapter.test.ts
@@ -1,6 +1,22 @@
import { describe, expect, it, vi } from 'vitest'
-import { createCodexFreshAgentAdapter } from '../../../../server/fresh-agent/adapters/codex/adapter.js'
+import { createCodexFreshAgentAdapter as createRawCodexFreshAgentAdapter } from '../../../../server/fresh-agent/adapters/codex/adapter.js'
+import { createCodexDisplayId } from '../../../../server/fresh-agent/adapters/codex/normalize.js'
+import {
+ FreshAgentInvalidDisplayIdError,
+ FreshAgentInvalidTurnCursorError,
+ FreshAgentStaleThreadRevisionError,
+ FreshAgentUnprovableThreadRevisionError,
+ FreshAgentTurnNotFoundError,
+} from '../../../../server/fresh-agent/runtime-manager.js'
+
+const DISPLAY_SECRET = 'task-3-persisted-display-secret'
+
+function createCodexFreshAgentAdapter(
+ deps: Omit[0], 'displayIdSecret'> & { displayIdSecret?: string },
+) {
+ return createRawCodexFreshAgentAdapter({ displayIdSecret: DISPLAY_SECRET, ...deps })
+}
function makeCodexThread(id: string) {
return {
@@ -33,7 +49,298 @@ function makeCodexTurn(id: string) {
}
}
+function makeMixedCodexTurn(id: string) {
+ return {
+ id,
+ status: 'completed',
+ items: [
+ {
+ type: 'userMessage',
+ id: `${id}:user`,
+ content: [{ type: 'text', text: 'Review the diff.' }],
+ },
+ {
+ type: 'reasoning',
+ id: `${id}:reasoning`,
+ summary: ['Checking changes'],
+ content: [],
+ },
+ {
+ type: 'agentMessage',
+ id: `${id}:assistant`,
+ text: 'The patch is safe.',
+ },
+ ],
+ }
+}
+
describe('Codex fresh-agent adapter', () => {
+ it('paginates Codex history by display rows within a split provider turn', async () => {
+ const firstTurn = makeMixedCodexTurn('turn-1')
+ const secondTurn = makeCodexTurn('turn-2')
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn()
+ .mockResolvedValueOnce({ revision: 7, nextCursor: 'provider-after-turn-1', turns: [firstTurn] })
+ .mockResolvedValueOnce({ revision: 7, nextCursor: null, turns: [secondTurn] }),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const firstPage: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1 })
+
+ expect(firstPage.turns).toHaveLength(1)
+ expect(firstPage.turns[0]).toMatchObject({ role: 'user', summary: 'Review the diff.' })
+ expect(firstPage.nextCursor).toMatch(/^codex-cursor:v1:[A-Za-z0-9_-]+$/)
+ expect(firstPage.nextCursor).not.toContain('provider-after-turn-1')
+ expect(firstPage.nextCursor).not.toContain('turn-1')
+ expect(() => JSON.parse(Buffer.from(firstPage.nextCursor.split(':').at(-1) ?? '', 'base64url').toString('utf8'))).toThrow()
+
+ const secondPage: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1, cursor: firstPage.nextCursor })
+
+ expect(secondPage.turns).toHaveLength(1)
+ expect(secondPage.turns[0]).toMatchObject({ role: 'assistant', summary: 'Checking changes' })
+ expect(secondPage.turns[0].turnId).not.toBe(firstPage.turns[0].turnId)
+ expect(runtime.listThreadTurns).toHaveBeenCalledTimes(1)
+
+ const thirdPage: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1, cursor: secondPage.nextCursor })
+
+ expect(thirdPage.turns).toHaveLength(1)
+ expect(thirdPage.turns[0]).toMatchObject({ role: 'assistant', summary: 'Codex summary' })
+ expect(thirdPage.nextCursor).toBeNull()
+ expect(runtime.listThreadTurns).toHaveBeenCalledTimes(2)
+ expect(runtime.listThreadTurns).toHaveBeenNthCalledWith(1, {
+ threadId: 'thread-new-1',
+ limit: 1,
+ itemsView: 'full',
+ })
+ expect(runtime.listThreadTurns).toHaveBeenNthCalledWith(2, {
+ threadId: 'thread-new-1',
+ cursor: 'provider-after-turn-1',
+ limit: 1,
+ itemsView: 'full',
+ })
+ })
+
+ it('does not refetch from the beginning after draining a final cached provider turn with a larger page limit', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 7,
+ nextCursor: null,
+ turns: [makeMixedCodexTurn('turn-1')],
+ }),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const firstPage: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1 })
+ expect(firstPage.turns).toHaveLength(1)
+ expect(firstPage.turns[0]).toMatchObject({ role: 'user' })
+
+ const secondPage: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 30, cursor: firstPage.nextCursor })
+
+ expect(secondPage.turns).toHaveLength(1)
+ expect(secondPage.turns[0]).toMatchObject({ role: 'assistant' })
+ expect(secondPage.turns.map((turn: any) => turn.turnId)).not.toContain(firstPage.turns[0].turnId)
+ expect(secondPage.nextCursor).toBeNull()
+ expect(runtime.listThreadTurns).toHaveBeenCalledTimes(1)
+ })
+
+ it('applies includeBodies to display-row limited pages with display turn body keys', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 7,
+ nextCursor: 'provider-after-turn-1',
+ turns: [makeMixedCodexTurn('turn-1')],
+ }),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const page: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1, includeBodies: true })
+
+ expect(page.turns).toHaveLength(1)
+ expect(Object.keys(page.bodies)).toEqual([page.turns[0].turnId])
+ expect(page.bodies[page.turns[0].turnId]).toMatchObject({ role: 'user' })
+ expect(page.bodies).not.toHaveProperty('turn-1')
+ })
+
+ it('rejects malformed, cross-thread, expired, and stale-revision display cursors with typed errors', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 7,
+ nextCursor: 'provider-after-turn-1',
+ turns: [makeMixedCodexTurn('turn-1')],
+ }),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+ const firstPage: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1 })
+
+ await expect(adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1, cursor: 'not-a-codex-cursor' })).rejects.toBeInstanceOf(FreshAgentInvalidTurnCursorError)
+
+ await expect(adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'other-thread',
+ }, { revision: 7, limit: 1, cursor: firstPage.nextCursor })).rejects.toBeInstanceOf(FreshAgentInvalidTurnCursorError)
+
+ await expect(adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 8, limit: 1, cursor: firstPage.nextCursor })).rejects.toBeInstanceOf(FreshAgentStaleThreadRevisionError)
+
+ await adapter.shutdown?.()
+ await expect(adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1, cursor: firstPage.nextCursor })).rejects.toBeInstanceOf(FreshAgentInvalidTurnCursorError)
+ })
+
+ it('throws a typed invalid display id error for malformed Codex display body ids', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn(),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: 'codex-display:v1:not-a-valid-envelope',
+ }, 7)).rejects.toBeInstanceOf(FreshAgentInvalidDisplayIdError)
+ expect(runtime.readThreadTurn).not.toHaveBeenCalled()
+ })
+
+ it('returns unprovable revision when an indexed display body no longer matches the provider turn body', async () => {
+ const durableTurn = makeMixedCodexTurn('turn-1')
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 7,
+ nextCursor: null,
+ turns: [durableTurn],
+ }),
+ readThreadTurn: vi.fn().mockResolvedValue(makeCodexTurn('turn-1')),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+ const page: any = await adapter.getTurnPage?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, { revision: 7, limit: 1 })
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: page.turns[0].turnId,
+ }, 7)).rejects.toBeInstanceOf(FreshAgentUnprovableThreadRevisionError)
+ })
+
+ it('rescans display indexes through provider pagination before returning an exact miss', async () => {
+ const targetTurn = makeMixedCodexTurn('turn-target')
+ const targetDisplayTurnId = createCodexDisplayId({
+ secret: DISPLAY_SECRET,
+ threadId: 'thread-new-1',
+ providerTurnId: 'turn-target',
+ role: 'user',
+ itemIds: ['turn-target:user'],
+ partIndexes: [0],
+ })
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn()
+ .mockResolvedValueOnce({
+ revision: 7,
+ nextCursor: 'provider-page-2',
+ turns: [makeCodexTurn('turn-before-target')],
+ })
+ .mockResolvedValueOnce({
+ revision: 7,
+ nextCursor: null,
+ turns: [targetTurn],
+ }),
+ readThreadTurn: vi.fn().mockResolvedValue(targetTurn),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: targetDisplayTurnId,
+ }, 7)).resolves.toMatchObject({
+ turnId: targetDisplayTurnId,
+ role: 'user',
+ summary: 'Review the diff.',
+ })
+ expect(runtime.listThreadTurns).toHaveBeenNthCalledWith(1, {
+ threadId: 'thread-new-1',
+ limit: 100,
+ itemsView: 'full',
+ })
+ expect(runtime.listThreadTurns).toHaveBeenNthCalledWith(2, {
+ threadId: 'thread-new-1',
+ cursor: 'provider-page-2',
+ limit: 100,
+ itemsView: 'full',
+ })
+ })
+
it('allocates separate runtimes for fresh Codex threads in different cwd values', async () => {
const runtimes = ['/repo/one', '/repo/two'].map((cwd, index) => ({
startThread: vi.fn().mockImplementation(async (input) => {
@@ -148,8 +455,7 @@ describe('Codex fresh-agent adapter', () => {
})
it('reads snapshots and turns from the official Codex thread APIs', async () => {
- const durableTurn = makeCodexTurn('turn-1')
- const expectedFullItem = expect.objectContaining({ kind: 'text', text: 'Codex summary' })
+ const durableTurn = makeMixedCodexTurn('turn-1')
const runtime = {
startThread: vi.fn(),
resumeThread: vi.fn(),
@@ -168,25 +474,292 @@ describe('Codex fresh-agent adapter', () => {
}
const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
- await expect(adapter.getSnapshot?.({ sessionType: 'freshcodex', provider: 'codex', threadId: 'thread-new-1' }, 7)).resolves.toMatchObject({
+ const snapshot: any = await adapter.getSnapshot?.({ sessionType: 'freshcodex', provider: 'codex', threadId: 'thread-new-1' }, 7)
+ expect(snapshot).toMatchObject({
provider: 'codex',
threadId: 'thread-new-1',
revision: 7,
- turns: [{ id: 'turn-1', turnId: 'turn-1' }],
})
+ expect(snapshot.turns).toHaveLength(2)
+ expect(snapshot.turns[0]).toMatchObject({ role: 'user', ordinal: 0 })
+ expect(snapshot.turns[1]).toMatchObject({ role: 'assistant', ordinal: 1 })
+ expect(snapshot.turns[0].turnId).toMatch(/^codex-display:v1:[A-Za-z0-9_-]{22}$/)
+ expect(snapshot.turns[1].turnId).toMatch(/^codex-display:v1:[A-Za-z0-9_-]{22}$/)
+ expect(snapshot.turns[0].turnId).not.toContain('turn-1')
+ expect(snapshot.turns[0]).not.toHaveProperty('providerTurnId')
expect(runtime.readThread).toHaveBeenCalledWith({ threadId: 'thread-new-1', includeTurns: true })
- await expect(adapter.getTurnPage?.({ sessionType: 'freshcodex', provider: 'codex', threadId: 'thread-new-1' }, { revision: 7 })).resolves.toMatchObject({
+ const page: any = await adapter.getTurnPage?.({ sessionType: 'freshcodex', provider: 'codex', threadId: 'thread-new-1' }, { revision: 7 })
+ expect(page).toMatchObject({
revision: 7,
- turns: [{ id: 'turn-1', turnId: 'turn-1', items: [expectedFullItem] }],
- bodies: { 'turn-1': expect.objectContaining({ items: [expectedFullItem] }) },
+ turns: [
+ expect.objectContaining({ role: 'user' }),
+ expect.objectContaining({ role: 'assistant' }),
+ ],
})
- await expect(adapter.getTurnBody?.({ sessionType: 'freshcodex', provider: 'codex', threadId: 'thread-new-1', turnId: 'turn-1' }, 7)).resolves.toMatchObject({
+ expect(page.turns[1].items).toEqual([
+ expect.objectContaining({ kind: 'reasoning' }),
+ expect.objectContaining({ kind: 'text', text: 'The patch is safe.' }),
+ ])
+ expect(page.bodies[page.turns[1].turnId]).toMatchObject({ role: 'assistant' })
+ await expect(adapter.getTurnBody?.({ sessionType: 'freshcodex', provider: 'codex', threadId: 'thread-new-1', turnId: page.turns[1].turnId }, 7)).resolves.toMatchObject({
+ turnId: page.turns[1].turnId,
+ revision: 7,
+ items: [
+ expect.objectContaining({ kind: 'reasoning' }),
+ expect.objectContaining({ kind: 'text', text: 'The patch is safe.' }),
+ ],
+ })
+ expect(runtime.readThreadTurn).toHaveBeenCalledWith({
+ threadId: 'thread-new-1',
turnId: 'turn-1',
revision: 7,
- items: [expectedFullItem],
})
})
+ it('keeps display ids short and opaque for long native ids and item ids', async () => {
+ const longProviderId = `turn-${'native-id-'.repeat(40)}`
+ const longItemId = `item-${'item-id-'.repeat(40)}`
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn().mockResolvedValue({
+ thread: {
+ ...makeCodexThread('thread-long-ids'),
+ updatedAt: 11,
+ turns: [{
+ id: longProviderId,
+ status: 'completed',
+ items: [{ type: 'agentMessage', id: longItemId, text: 'Short public id' }],
+ }],
+ },
+ }),
+ listThreadTurns: vi.fn(),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const snapshot: any = await adapter.getSnapshot?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-long-ids',
+ }, 11)
+
+ expect(snapshot.turns[0].turnId).toMatch(/^codex-display:v1:[A-Za-z0-9_-]{22}$/)
+ expect(snapshot.turns[0].turnId.length).toBeLessThan(45)
+ expect(snapshot.turns[0].turnId).not.toContain(longProviderId.slice(0, 20))
+ expect(snapshot.turns[0].turnId).not.toContain(longItemId.slice(0, 20))
+ })
+
+ it('does not pass unknown or malformed display ids to Codex body reads', async () => {
+ const durableTurn = makeMixedCodexTurn('turn-1')
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn().mockResolvedValue({
+ thread: { ...makeCodexThread('thread-new-1'), turns: [durableTurn] },
+ }),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 7,
+ nextCursor: null,
+ turns: [durableTurn],
+ }),
+ readThreadTurn: vi.fn().mockResolvedValue(durableTurn),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: 'codex-display:v1:not-a-valid-envelope',
+ }, 7)).rejects.toBeInstanceOf(FreshAgentInvalidDisplayIdError)
+ expect(runtime.readThreadTurn).not.toHaveBeenCalled()
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: 'codex-display:v1:abcdefghijklmnopqrstu1',
+ }, 7)).rejects.toBeInstanceOf(FreshAgentTurnNotFoundError)
+ expect(runtime.readThreadTurn).not.toHaveBeenCalled()
+ })
+
+ it('returns stale revision when a display body read has no matching cached revision', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 9,
+ nextCursor: null,
+ turns: [makeMixedCodexTurn('turn-current')],
+ }),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: 'codex-display:v1:abcdefghijklmnopqrstu1',
+ }, 7)).rejects.toBeInstanceOf(FreshAgentStaleThreadRevisionError)
+ expect(runtime.readThreadTurn).not.toHaveBeenCalled()
+ })
+
+ it('accepts native body ids only when they normalize to one display row', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn(),
+ listThreadTurns: vi.fn(),
+ readThreadTurn: vi.fn()
+ .mockResolvedValueOnce(makeCodexTurn('turn-single'))
+ .mockResolvedValueOnce(makeMixedCodexTurn('turn-mixed')),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const single: any = await adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: 'turn-single',
+ }, 7)
+ expect(single.turnId).toMatch(/^codex-display:v1:/)
+ expect(single.items).toEqual([expect.objectContaining({ text: 'Codex summary' })])
+
+ await expect(adapter.getTurnBody?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ turnId: 'turn-mixed',
+ }, 7)).rejects.toThrow(/display turns/)
+ })
+
+ it('materializes submitted input rows until Codex returns the provider user message', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ startTurn: vi.fn().mockResolvedValue({ turnId: 'turn-submitted-1' }),
+ readThread: vi.fn()
+ .mockResolvedValueOnce({
+ thread: {
+ ...makeCodexThread('thread-new-1'),
+ updatedAt: 8,
+ turns: [{
+ id: 'turn-submitted-1',
+ status: 'inProgress',
+ items: [{ type: 'agentMessage', id: 'assistant-1', text: 'Working on it.' }],
+ }],
+ },
+ })
+ .mockResolvedValueOnce({
+ thread: {
+ ...makeCodexThread('thread-new-1'),
+ updatedAt: 9,
+ turns: [{
+ id: 'turn-submitted-1',
+ status: 'completed',
+ items: [
+ { type: 'userMessage', id: 'real-user-1', content: [{ type: 'text', text: 'Review this image' }] },
+ { type: 'agentMessage', id: 'assistant-1', text: 'Done.' },
+ ],
+ }],
+ },
+ }),
+ listThreadTurns: vi.fn(),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const sendResult: any = await adapter.send?.('thread-new-1', {
+ requestId: 'send-1',
+ text: 'Review this image',
+ images: [
+ { kind: 'local', path: '/tmp/screenshot.png', mediaType: 'image/png' },
+ { kind: 'data', mediaType: 'image/png', data: 'abc123' },
+ ],
+ })
+
+ expect(sendResult).toMatchObject({
+ requestId: 'send-1',
+ submittedTurnId: expect.stringMatching(/^codex-display:v1:/),
+ })
+ expect(runtime.startTurn).toHaveBeenCalledWith(expect.objectContaining({
+ input: [
+ { type: 'text', text: 'Review this image', text_elements: [] },
+ { type: 'localImage', path: '/tmp/screenshot.png' },
+ { type: 'image', url: 'data:image/png;base64,abc123' },
+ ],
+ }))
+
+ const pendingSnapshot: any = await adapter.getSnapshot?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, 8)
+ expect(pendingSnapshot.turns[0]).toMatchObject({
+ turnId: sendResult.submittedTurnId,
+ role: 'user',
+ source: 'durable',
+ })
+ expect(pendingSnapshot.turns[0].summary).toBe('Review this image')
+
+ const materializedSnapshot: any = await adapter.getSnapshot?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, 9)
+ expect(materializedSnapshot.turns[0]).toMatchObject({
+ turnId: sendResult.submittedTurnId,
+ role: 'user',
+ })
+ expect(materializedSnapshot.turns.filter((turn: any) => turn.role === 'user')).toHaveLength(1)
+ })
+
+ it('keeps same-text queued submitted rows distinct by request id', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ startTurn: vi.fn()
+ .mockResolvedValueOnce({ turnId: 'turn-submitted-1' })
+ .mockResolvedValueOnce({ turnId: 'turn-submitted-2' }),
+ readThread: vi.fn().mockResolvedValue({
+ thread: {
+ ...makeCodexThread('thread-new-1'),
+ updatedAt: 8,
+ turns: [
+ {
+ id: 'turn-submitted-1',
+ status: 'inProgress',
+ items: [{ type: 'agentMessage', id: 'assistant-1', text: 'Working.' }],
+ },
+ {
+ id: 'turn-submitted-2',
+ status: 'inProgress',
+ items: [{ type: 'agentMessage', id: 'assistant-2', text: 'Still working.' }],
+ },
+ ],
+ },
+ }),
+ listThreadTurns: vi.fn(),
+ readThreadTurn: vi.fn(),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtime: runtime as any })
+
+ const first: any = await adapter.send?.('thread-new-1', { requestId: 'send-1', text: 'Same prompt' })
+ const second: any = await adapter.send?.('thread-new-1', { requestId: 'send-2', text: 'Same prompt' })
+ const snapshot: any = await adapter.getSnapshot?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-new-1',
+ }, 8)
+
+ const userRows = snapshot.turns.filter((turn: any) => turn.role === 'user')
+ expect(first.submittedTurnId).not.toBe(second.submittedTurnId)
+ expect(userRows.map((turn: any) => turn.turnId)).toEqual([first.submittedTurnId, second.submittedTurnId])
+ })
+
it('reads a just-created Codex thread without turns when includeTurns is not materialized yet', async () => {
const runtime = {
startThread: vi.fn().mockResolvedValue({
@@ -257,6 +830,41 @@ describe('Codex fresh-agent adapter', () => {
expect(runtime.shutdown).toHaveBeenCalledTimes(1)
})
+ it('lazily resumes a Codex runtime in the saved cwd before reading a persisted thread after server reload', async () => {
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn().mockResolvedValue({
+ threadId: 'thread-existing-cwd',
+ wsUrl: 'ws://127.0.0.1:43123',
+ }),
+ readThread: vi.fn().mockResolvedValue({
+ thread: makeCodexThread('thread-existing-cwd'),
+ }),
+ listThreadTurns: vi.fn(),
+ readThreadTurn: vi.fn(),
+ shutdown: vi.fn().mockResolvedValue(undefined),
+ }
+ const adapter = createCodexFreshAgentAdapter({ runtimeFactory: vi.fn(() => runtime) as any })
+
+ await expect(adapter.getSnapshot?.({
+ sessionType: 'freshcodex',
+ provider: 'codex',
+ threadId: 'thread-existing-cwd',
+ cwd: '/repo/persisted-worktree',
+ } as any, 7)).resolves.toMatchObject({
+ provider: 'codex',
+ threadId: 'thread-existing-cwd',
+ })
+
+ expect(runtime.resumeThread).toHaveBeenCalledWith({
+ threadId: 'thread-existing-cwd',
+ cwd: '/repo/persisted-worktree',
+ })
+
+ await adapter.shutdown?.()
+ expect(runtime.shutdown).toHaveBeenCalledTimes(1)
+ })
+
it('dedupes concurrent lazy runtime resumes for the same persisted thread', async () => {
let resolveResume: ((value: { threadId: string; wsUrl: string }) => void) | undefined
const resumePromise = new Promise<{ threadId: string; wsUrl: string }>((resolve) => {
@@ -393,26 +1001,20 @@ describe('Codex fresh-agent adapter', () => {
model: 'gpt-5-codex',
})
await adapter.send?.('thread-new-1', {
+ requestId: 'send-model-1',
text: 'Use the small model',
settings: { model: 'gpt-5.4-flash' },
})
- await expect(adapter.getSnapshot?.({
- sessionType: 'freshcodex',
- provider: 'codex',
- threadId: 'thread-new-1',
- }, 7)).resolves.toMatchObject({
- turns: [
- { id: 'turn-1' },
- { id: 'turn-2', model: 'gpt-5.4-flash' },
- ],
- })
const snapshot = await adapter.getSnapshot?.({
sessionType: 'freshcodex',
provider: 'codex',
threadId: 'thread-new-1',
}, 7) as any
+ expect(snapshot.turns).toHaveLength(3)
expect(snapshot.turns[0]).not.toHaveProperty('model')
+ expect(snapshot.turns[1]).toMatchObject({ role: 'user', model: 'gpt-5.4-flash' })
+ expect(snapshot.turns[2]).toMatchObject({ role: 'assistant', model: 'gpt-5.4-flash' })
})
it('subscribes to Codex lifecycle notifications and projects matching thread updates', async () => {
diff --git a/test/unit/server/fresh-agent/codex-normalize.test.ts b/test/unit/server/fresh-agent/codex-normalize.test.ts
index 7f53993c5..e235b8d51 100644
--- a/test/unit/server/fresh-agent/codex-normalize.test.ts
+++ b/test/unit/server/fresh-agent/codex-normalize.test.ts
@@ -1,10 +1,36 @@
import { describe, expect, it } from 'vitest'
+import { CodexThreadItemTypeSchema } from '../../../../server/coding-cli/codex-app-server/protocol.js'
import {
+ CodexDisplayConfigError,
+ createCodexDisplayId,
+ normalizeCodexDisplayTurns,
normalizeCodexThreadSnapshot,
normalizeCodexTurn,
+ normalizeCodexTurnBody,
+ parseCodexDisplayIdHandle,
} from '../../../../server/fresh-agent/adapters/codex/normalize.js'
+const DISPLAY_SECRET = 'task-2-deterministic-secret'
+const THREAD_ID = 'thread-codex-1'
+
+function normalizeDisplayTurns(
+ rawTurn: Record,
+ overrides: {
+ model?: string
+ secret?: string
+ threadId?: string
+ submittedRequestIdByProviderTurnId?: Map
+ } = {},
+) {
+ return normalizeCodexDisplayTurns(rawTurn, 0, {
+ model: 'gpt-5.4-mini',
+ secret: DISPLAY_SECRET,
+ threadId: THREAD_ID,
+ ...overrides,
+ })
+}
+
describe('Codex fresh-agent normalization', () => {
it('normalizes codex fork, review, worktree, and child-thread metadata into the shared snapshot', () => {
const snapshot = normalizeCodexThreadSnapshot({
@@ -59,7 +85,7 @@ describe('Codex fresh-agent normalization', () => {
expect(snapshot.diffs[0]).toMatchObject({ path: 'src/app.ts' })
})
- it('surfaces the Codex turn model in the shared turn state', () => {
+ it('surfaces the Codex turn model in the shared turn state for single-row turns', () => {
const turn = normalizeCodexTurn({
id: 'turn-1',
model: 'gpt-5.4-mini',
@@ -70,15 +96,15 @@ describe('Codex fresh-agent normalization', () => {
text: 'Done',
},
],
- })
+ }, 0, { threadId: THREAD_ID, secret: DISPLAY_SECRET })
expect(turn).toMatchObject({
- id: 'turn-1',
- turnId: 'turn-1',
model: 'gpt-5.4-mini',
role: 'assistant',
summary: 'Done',
})
+ expect(turn.turnId).toMatch(/^codex-display:v1:/)
+ expect(turn.id).toBe(turn.turnId)
})
it('uses the active runtime model as a fallback when Codex omits per-turn model metadata', () => {
@@ -91,73 +117,489 @@ describe('Codex fresh-agent normalization', () => {
text: 'Done',
},
],
- }, 0, { model: 'gpt-5.4-mini' })
+ }, 0, { threadId: THREAD_ID, model: 'gpt-5.4-mini', secret: DISPLAY_SECRET })
expect(turn.model).toBe('gpt-5.4-mini')
})
- it('marks user-only Codex turns and explains an empty assistant response', () => {
- const turn = normalizeCodexTurn({
- id: 'turn-empty',
+ it('segments mixed user, reasoning, and agent output into user then assistant display rows', () => {
+ const { turns, displayRows } = normalizeDisplayTurns({
+ id: 'turn-mixed',
+ status: 'completed',
+ items: [
+ {
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Review the diff.' }],
+ },
+ {
+ id: 'item-reasoning',
+ type: 'reasoning',
+ summary: ['Comparing changed files'],
+ content: ['Walking the patch'],
+ },
+ {
+ id: 'item-agent',
+ type: 'agentMessage',
+ text: 'I found two regressions.',
+ },
+ ],
+ })
+
+ expect(turns).toHaveLength(2)
+ expect(turns.map((turn) => turn.role)).toEqual(['user', 'assistant'])
+ expect(turns[0]?.items).toEqual([
+ { id: 'item-user:part:0', kind: 'text', text: 'Review the diff.' },
+ ])
+ expect(turns[1]?.items.map((item) => item.kind)).toEqual(['reasoning', 'text'])
+ expect(displayRows.map((row) => row.role)).toEqual(['user', 'assistant'])
+ })
+
+ it('uses thread-bound display ids for the same native provider turn id', () => {
+ const first = createCodexDisplayId({
+ secret: DISPLAY_SECRET,
+ threadId: 'thread-alpha',
+ providerTurnId: 'turn-shared',
+ role: 'assistant',
+ itemIds: ['item-agent'],
+ partIndexes: [0],
+ })
+ const second = createCodexDisplayId({
+ secret: DISPLAY_SECRET,
+ threadId: 'thread-beta',
+ providerTurnId: 'turn-shared',
+ role: 'assistant',
+ itemIds: ['item-agent'],
+ partIndexes: [0],
+ })
+
+ expect(first).not.toBe(second)
+ })
+
+ it('keeps display ids short and opaque to native ids, prompt text, and cursor payloads', () => {
+ const turnId = createCodexDisplayId({
+ secret: DISPLAY_SECRET,
+ threadId: THREAD_ID,
+ providerTurnId: 'provider-turn-123',
+ role: 'user',
+ itemIds: ['provider-item-987'],
+ partIndexes: [0],
+ })
+ const parsed = parseCodexDisplayIdHandle(turnId)
+ const decodedHandle = parsed ? Buffer.from(parsed.handle, 'base64url').toString('utf8') : ''
+
+ expect(turnId.length).toBeLessThan(48)
+ expect(turnId).not.toContain('provider-turn-123')
+ expect(turnId).not.toContain('provider-item-987')
+ expect(turnId).not.toContain('printenv SECRET_TOKEN')
+ expect(turnId).not.toContain('cursor:opaque-payload')
+ expect(decodedHandle).not.toContain('provider-turn-123')
+ expect(decodedHandle).not.toContain('provider-item-987')
+ expect(decodedHandle).not.toContain('printenv SECRET_TOKEN')
+ expect(decodedHandle).not.toContain('cursor:opaque-payload')
+ })
+
+ it('fails display normalization when the adapter does not supply a non-empty secret', () => {
+ expect(() => normalizeCodexDisplayTurns({
+ id: 'turn-missing-secret',
status: 'completed',
items: [{
- id: 'item-1',
+ id: 'item-user',
type: 'userMessage',
- content: [{ type: 'text', text: 'Write a temp file.' }],
+ content: [{ type: 'text', text: 'Prompt' }],
}],
- })
+ }, 0, {
+ threadId: THREAD_ID,
+ secret: '',
+ })).toThrow(CodexDisplayConfigError)
- expect(turn.role).toBe('user')
- expect(turn.items).toEqual([
- { id: 'item-1:part:0', kind: 'text', text: 'Write a temp file.' },
- {
- id: 'turn-empty:empty-response',
- kind: 'text',
- text: 'Codex completed this turn without recording an assistant response.',
- },
- ])
+ expect(() => normalizeCodexDisplayTurns({
+ id: 'turn-missing-secret',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Prompt' }],
+ }],
+ }, 0, {
+ threadId: THREAD_ID,
+ })).toThrow(/non-empty.*secret/i)
})
- it('does not add an empty response sentinel to user turns with tool output', () => {
- const turn = normalizeCodexTurn({
- id: 'turn-tool-only',
+ it('fails display normalization when the adapter does not supply a non-empty threadId', () => {
+ expect(() => normalizeCodexDisplayTurns({
+ id: 'turn-missing-thread',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Prompt' }],
+ }],
+ }, 0, {
+ secret: DISPLAY_SECRET,
+ threadId: '',
+ })).toThrow(CodexDisplayConfigError)
+
+ expect(() => normalizeCodexDisplayTurns({
+ id: 'turn-missing-thread',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Prompt' }],
+ }],
+ }, 0, {
+ secret: DISPLAY_SECRET,
+ })).toThrow(/non-empty.*threadId/i)
+ })
+
+ it('preserves existing display ids when unrelated rows are inserted later in the provider turn', () => {
+ const base = normalizeDisplayTurns({
+ id: 'turn-inserted',
status: 'completed',
items: [
{
- id: 'item-1',
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Run the tests.' }],
+ },
+ {
+ id: 'item-command',
+ type: 'commandExecution',
+ command: 'npm test',
+ status: 'completed',
+ aggregatedOutput: 'ok',
+ exitCode: 0,
+ },
+ ],
+ }).turns
+ const expanded = normalizeDisplayTurns({
+ id: 'turn-inserted',
+ status: 'completed',
+ items: [
+ {
+ id: 'item-user',
type: 'userMessage',
- content: [{ type: 'text', text: 'Write a temp file.' }],
+ content: [{ type: 'text', text: 'Run the tests.' }],
+ },
+ {
+ id: 'item-agent',
+ type: 'agentMessage',
+ text: 'Running them now.',
},
{
- id: 'item-2',
+ id: 'item-command',
type: 'commandExecution',
- command: 'cat temp.txt',
+ command: 'npm test',
status: 'completed',
aggregatedOutput: 'ok',
exitCode: 0,
},
],
+ }).turns
+
+ expect(base.map((turn) => turn.role)).toEqual(['user', 'tool'])
+ expect(expanded.map((turn) => turn.role)).toEqual(['user', 'assistant', 'tool'])
+ expect(base[0]?.turnId).toBe(expanded[0]?.turnId)
+ expect(base[1]?.turnId).toBe(expanded[2]?.turnId)
+ })
+
+ it('segments assistant output away from later tool items', () => {
+ const { turns } = normalizeDisplayTurns({
+ id: 'turn-tools',
+ status: 'completed',
+ items: [
+ {
+ id: 'item-agent',
+ type: 'agentMessage',
+ text: 'Applied the patch.',
+ },
+ {
+ id: 'item-command',
+ type: 'commandExecution',
+ command: 'npm test',
+ status: 'completed',
+ aggregatedOutput: 'ok',
+ exitCode: 0,
+ },
+ {
+ id: 'item-file-change',
+ type: 'fileChange',
+ status: 'completed',
+ changes: [{ path: 'src/app.ts', changeType: 'modified' }],
+ },
+ ],
})
- expect(turn.items.map((item) => item.id)).not.toContain('turn-tool-only:empty-response')
+ expect(turns).toHaveLength(2)
+ expect(turns.map((turn) => turn.role)).toEqual(['assistant', 'tool'])
+ expect(turns[1]?.items.map((item) => item.kind)).toEqual(['command', 'file_change'])
})
- it('surfaces Codex turn errors in transcript text', () => {
- const turn = normalizeCodexTurn({
+ it('classifies every Codex thread item type into a normalized display role', () => {
+ const factories: Record<(typeof CodexThreadItemTypeSchema.options)[number], Record> = {
+ userMessage: { type: 'userMessage', content: [{ type: 'text', text: 'Prompt' }] },
+ hookPrompt: { type: 'hookPrompt' },
+ agentMessage: { type: 'agentMessage', text: 'Done' },
+ plan: { type: 'plan', text: '1. Do the work' },
+ reasoning: { type: 'reasoning', summary: ['Thinking'], content: ['Longer trace'] },
+ commandExecution: { type: 'commandExecution', command: 'npm test', status: 'completed', aggregatedOutput: 'ok', exitCode: 0 },
+ fileChange: { type: 'fileChange', status: 'completed', changes: [{ path: 'src/app.ts' }] },
+ mcpToolCall: { type: 'mcpToolCall', server: 'docs', tool: 'search', status: 'completed', arguments: { q: 'codex' }, result: { ok: true } },
+ dynamicToolCall: { type: 'dynamicToolCall', namespace: 'tools', tool: 'exec', status: 'completed', arguments: { cmd: 'pwd' }, contentItems: [], success: true },
+ collabAgentToolCall: { type: 'collabAgentToolCall', tool: 'dispatch', status: 'completed', senderThreadId: 'thread-parent', receiverThreadIds: ['thread-child'], agentsStates: {} },
+ webSearch: { type: 'webSearch', query: 'freshell' },
+ imageView: { type: 'imageView', path: '/tmp/screenshot.png' },
+ imageGeneration: { type: 'imageGeneration', status: 'completed', result: 'saved', revisedPrompt: 'prompt' },
+ enteredReviewMode: { type: 'enteredReviewMode', review: 'security' },
+ exitedReviewMode: { type: 'exitedReviewMode', review: 'security' },
+ contextCompaction: { type: 'contextCompaction' },
+ }
+ const expectedRoles: Record<(typeof CodexThreadItemTypeSchema.options)[number], string> = {
+ userMessage: 'user',
+ hookPrompt: 'system',
+ agentMessage: 'assistant',
+ plan: 'assistant',
+ reasoning: 'assistant',
+ commandExecution: 'tool',
+ fileChange: 'tool',
+ mcpToolCall: 'tool',
+ dynamicToolCall: 'tool',
+ collabAgentToolCall: 'tool',
+ webSearch: 'tool',
+ imageView: 'tool',
+ imageGeneration: 'tool',
+ enteredReviewMode: 'system',
+ exitedReviewMode: 'system',
+ contextCompaction: 'system',
+ }
+
+ for (const type of CodexThreadItemTypeSchema.options) {
+ const result = normalizeDisplayTurns({
+ id: `turn-${type}`,
+ status: 'inProgress',
+ items: [{ id: `item-${type}`, ...factories[type] }],
+ })
+
+ expect(result.turns).toHaveLength(1)
+ expect(result.turns[0]?.role).toBe(expectedRoles[type])
+ }
+ })
+
+ it('extracts user text from content, then input_text, then text, then summary', () => {
+ const fromContent = normalizeDisplayTurns({
+ id: 'turn-content',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ text: 'fallback text',
+ summary: 'fallback summary',
+ content: [{ type: 'text', text: 'from content array' }],
+ }],
+ }).turns[0]
+ const fromInputText = normalizeDisplayTurns({
+ id: 'turn-input-text',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'input_text', text: 'from input_text part' }],
+ }],
+ }).turns[0]
+ const fromText = normalizeDisplayTurns({
+ id: 'turn-text',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ text: 'from top-level text',
+ }],
+ }).turns[0]
+ const fromSummary = normalizeDisplayTurns({
+ id: 'turn-summary',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ summary: 'from top-level summary',
+ }],
+ }).turns[0]
+
+ expect(fromContent?.items[0]).toMatchObject({ kind: 'text', text: 'from content array' })
+ expect(fromInputText?.items[0]).toMatchObject({ kind: 'text', text: 'from input_text part' })
+ expect(fromText?.items[0]).toMatchObject({ kind: 'text', text: 'from top-level text' })
+ expect(fromSummary?.items[0]).toMatchObject({ kind: 'text', text: 'from top-level summary' })
+ })
+
+ it('adds an assistant empty-response sentinel after completed user-only turns', () => {
+ const turns = normalizeDisplayTurns({
+ id: 'turn-empty',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Write a temp file.' }],
+ }],
+ }).turns
+
+ expect(turns.map((turn) => turn.role)).toEqual(['user', 'assistant'])
+ expect(turns[1]?.items).toEqual([
+ {
+ id: 'codex-display-synthetic:empty-response',
+ kind: 'text',
+ text: 'Codex completed this turn without recording an assistant response.',
+ },
+ ])
+ })
+
+ it('adds an assistant error row after failed user-only turns', () => {
+ const turns = normalizeDisplayTurns({
id: 'turn-error',
status: 'failed',
error: { message: 'model rejected the request' },
items: [{
- id: 'item-1',
+ id: 'item-user',
type: 'userMessage',
content: [{ type: 'text', text: 'Do the thing.' }],
}],
+ }).turns
+
+ expect(turns.map((turn) => turn.role)).toEqual(['user', 'assistant'])
+ expect(turns[1]?.items).toEqual([
+ {
+ id: 'codex-display-synthetic:error',
+ kind: 'text',
+ text: 'Codex turn failed: model rejected the request',
+ },
+ ])
+ })
+
+ it('throws a protocol error when a provider item that participates in identity is missing an id', () => {
+ expect(() => normalizeDisplayTurns({
+ id: 'turn-missing-item-id',
+ status: 'completed',
+ items: [{
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Prompt' }],
+ }],
+ })).toThrow(/protocol|stable item id/i)
+ })
+
+ it('reuses submitted user display ids when the provider userMessage later materializes', () => {
+ const requestId = 'request-42'
+ const submittedTurnId = createCodexDisplayId({
+ secret: DISPLAY_SECRET,
+ threadId: THREAD_ID,
+ providerTurnId: 'turn-submitted',
+ role: 'user',
+ syntheticKind: 'submitted-input',
+ requestId,
})
+ const turns = normalizeDisplayTurns({
+ id: 'turn-submitted',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Ship it.' }],
+ }],
+ }, {
+ submittedRequestIdByProviderTurnId: new Map([['turn-submitted', requestId]]),
+ }).turns
+
+ expect(turns[0]?.turnId).toBe(submittedTurnId)
+ })
+
+ it('rejects malformed codex-display prefixes as invalid public ids', () => {
+ expect(parseCodexDisplayIdHandle('codex-display:not-a-valid-envelope')).toBeNull()
+ })
+
+ it('selects the exact requested display row for turn bodies and throws when it is absent', () => {
+ const rawTurn = {
+ id: 'turn-body',
+ status: 'completed',
+ items: [
+ {
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Review the diff.' }],
+ },
+ {
+ id: 'item-reasoning',
+ type: 'reasoning',
+ summary: ['Comparing changed files'],
+ content: ['Walking the patch'],
+ },
+ {
+ id: 'item-agent',
+ type: 'agentMessage',
+ text: 'I found two regressions.',
+ },
+ ],
+ }
+ const turns = normalizeDisplayTurns(rawTurn).turns
+ const assistantTurnId = turns[1]?.turnId
+ expect(assistantTurnId).toBeTruthy()
- expect(turn.items.at(-1)).toEqual({
- id: 'turn-error:error',
- kind: 'text',
- text: 'Codex turn failed: model rejected the request',
+ const assistantBody = normalizeCodexTurnBody({
+ threadId: THREAD_ID,
+ revision: 9,
+ requestedTurnId: assistantTurnId ?? '',
+ rawTurn,
+ model: 'gpt-5.4-mini',
+ secret: DISPLAY_SECRET,
})
+
+ expect(assistantBody.turnId).toBe(assistantTurnId)
+ expect(assistantBody.role).toBe('assistant')
+ expect(assistantBody.items.map((item) => item.kind)).toEqual(['reasoning', 'text'])
+ expect(() => normalizeCodexTurnBody({
+ threadId: THREAD_ID,
+ revision: 9,
+ requestedTurnId: 'codex-display:v1:not-found-handle',
+ rawTurn,
+ model: 'gpt-5.4-mini',
+ secret: DISPLAY_SECRET,
+ })).toThrow(/not found/i)
+
+ expect(() => normalizeCodexTurnBody({
+ threadId: THREAD_ID,
+ revision: 9,
+ requestedTurnId: '',
+ rawTurn,
+ model: 'gpt-5.4-mini',
+ secret: DISPLAY_SECRET,
+ })).toThrow(/not found/i)
+
+ expect(() => normalizeCodexTurnBody({
+ threadId: THREAD_ID,
+ revision: 9,
+ requestedTurnId: undefined as unknown as string,
+ rawTurn,
+ model: 'gpt-5.4-mini',
+ secret: DISPLAY_SECRET,
+ })).toThrow(/not found/i)
+ })
+
+ it('fails body normalization when the adapter does not supply a non-empty secret', () => {
+ const rawTurn = {
+ id: 'turn-body-secret',
+ status: 'completed',
+ items: [{
+ id: 'item-user',
+ type: 'userMessage',
+ content: [{ type: 'text', text: 'Review the diff.' }],
+ }],
+ }
+
+ expect(() => normalizeCodexTurnBody({
+ threadId: THREAD_ID,
+ revision: 9,
+ requestedTurnId: 'codex-display:v1:missingsecret0000',
+ rawTurn,
+ model: 'gpt-5.4-mini',
+ secret: '',
+ })).toThrow(CodexDisplayConfigError)
})
})
diff --git a/test/unit/server/fresh-agent/opencode-normalize.test.ts b/test/unit/server/fresh-agent/opencode-normalize.test.ts
index 0c8bb46f4..9998be50b 100644
--- a/test/unit/server/fresh-agent/opencode-normalize.test.ts
+++ b/test/unit/server/fresh-agent/opencode-normalize.test.ts
@@ -37,7 +37,7 @@ describe('OpenCode fresh-agent normalization', () => {
summary: 'Compacted older OpenCode context.',
},
],
- }, 0)
+ }, 0)!
expect(turn.items).toEqual([
{
@@ -70,9 +70,9 @@ describe('OpenCode fresh-agent normalization', () => {
it('guards missing patch files and returns an empty completed file change', () => {
const turn = normalizeOpencodeTurn({
- info: { id: 'msg-patch' },
+ info: { id: 'msg-patch', role: 'assistant' },
parts: [{ id: 'part-patch-empty', type: 'patch', diff: '@@ empty @@' }],
- }, 0)
+ }, 0)!
expect(turn.items).toEqual([
{
@@ -161,7 +161,7 @@ describe('OpenCode fresh-agent normalization', () => {
const turn = normalizeOpencodeTurn({
info: { id: 'msg-user-quoted', role: 'user' },
parts: [{ id: 'part-user-quoted', type: 'text', text: '"Do a directory listing."' }],
- }, 0)
+ }, 0)!
expect(turn.role).toBe('user')
expect(turn.items).toEqual([
@@ -174,7 +174,7 @@ describe('OpenCode fresh-agent normalization', () => {
const turn = normalizeOpencodeTurn({
info: { id: 'msg-user-plain', role: 'user' },
parts: [{ id: 'part-user-plain', type: 'text', text: 'Do a directory listing.' }],
- }, 0)
+ }, 0)!
expect(turn.items[0]?.text).toBe('Do a directory listing.')
expect(turn.summary).toBe('Do a directory listing.')
@@ -184,7 +184,7 @@ describe('OpenCode fresh-agent normalization', () => {
const turn = normalizeOpencodeTurn({
info: { id: 'msg-assistant-quoted', role: 'assistant' },
parts: [{ id: 'part-assistant-quoted', type: 'text', text: '"Hello, world."' }],
- }, 0)
+ }, 0)!
expect(turn.role).toBe('assistant')
expect(turn.items[0]?.text).toBe('"Hello, world."')
@@ -194,7 +194,7 @@ describe('OpenCode fresh-agent normalization', () => {
const turn = normalizeOpencodeTurn({
info: { id: 'msg-user-nested', role: 'user' },
parts: [{ id: 'part-user-nested', type: 'text', text: '""nested" quotes"' }],
- }, 0)
+ }, 0)!
expect(turn.items[0]?.text).toBe('"nested" quotes')
})
@@ -214,7 +214,7 @@ describe('OpenCode fresh-agent normalization', () => {
text: 'Intro I could change all instances. done.',
},
],
- }, 0)
+ }, 0)!
expect(turn.items).toEqual([
{ id: 'part-think', kind: 'text', text: 'Before and after.' },
@@ -229,7 +229,7 @@ describe('OpenCode fresh-agent normalization', () => {
parts: [
{ id: 'part-user-think', type: 'text', text: 'Why did the assistant say secret?' },
],
- }, 0)
+ }, 0)!
expect(turn.items).toEqual([
{ id: 'part-user-think', kind: 'text', text: 'Why did the assistant say secret?' },
@@ -240,7 +240,7 @@ describe('OpenCode fresh-agent normalization', () => {
const turn = normalizeOpencodeTurn({
info: { id: 'msg-preserve-ws', role: 'assistant' },
parts: [{ id: 'part-ws', type: 'text', text: ' leading\n and trailing ' }],
- }, 0)
+ }, 0)!
expect(turn.items).toEqual([{ id: 'part-ws', kind: 'text', text: ' leading\n and trailing ' }])
})
@@ -250,13 +250,65 @@ describe('OpenCode fresh-agent normalization', () => {
const turn = normalizeOpencodeTurn({
info: { id: 'msg-reasoning', role: 'assistant' },
parts: [{ id: 'part-reasoning', type: 'reasoning', text }],
- }, 0)
+ }, 0)!
expect(turn.items).toEqual([
{ id: 'part-reasoning', kind: 'reasoning', summary: [text], content: [text], text },
])
})
+ it('keeps user and assistant messages as separate display turns with their native turnIds', () => {
+ const snapshot = normalizeOpencodeSnapshot({
+ sessionType: 'freshopencode',
+ threadId: 'ses-separated-turns',
+ exported: {
+ messages: [
+ {
+ info: { id: 'msg-user', role: 'user' },
+ parts: [{ id: 'part-user', type: 'text', text: 'Summarize the changes.' }],
+ },
+ {
+ info: { id: 'msg-assistant', role: 'assistant' },
+ parts: [{ id: 'part-assistant', type: 'text', text: 'Summarizing now.' }],
+ },
+ ],
+ },
+ })
+
+ expect(snapshot.turns).toHaveLength(2)
+ expect(snapshot.turns).toMatchObject([
+ { turnId: 'msg-user', messageId: 'msg-user', role: 'user', summary: 'Summarize the changes.' },
+ { turnId: 'msg-assistant', messageId: 'msg-assistant', role: 'assistant', summary: 'Summarizing now.' },
+ ])
+ })
+
+ it('rejects visible roleless messages instead of emitting roleless display turns', () => {
+ const message = {
+ info: { id: 'msg-roleless' },
+ parts: [{ id: 'part-roleless', type: 'text', text: 'Hidden until OpenCode provides a display role.' }],
+ }
+
+ expect(normalizeOpencodeTurn(message, 0)).toBeNull()
+
+ const snapshot = normalizeOpencodeSnapshot({
+ sessionType: 'freshopencode',
+ threadId: 'ses-roleless',
+ exported: {
+ messages: [
+ {
+ info: { id: 'msg-user', role: 'user' },
+ parts: [{ id: 'part-user', type: 'text', text: 'User input' }],
+ },
+ message,
+ ],
+ },
+ })
+
+ expect(snapshot.turns).toHaveLength(1)
+ expect(snapshot.turns[0]).toMatchObject({ turnId: 'msg-user', role: 'user' })
+ expect(snapshot.turns.some((turn) => turn.turnId === 'msg-roleless')).toBe(false)
+ })
+
it('carries turn-page nextCursor explicitly and keeps export fallback compatibility', () => {
const explicit = normalizeOpencodeTurnPage({
threadId: 'ses-page',
diff --git a/test/unit/server/fresh-agent/opencode-serve-adapter.test.ts b/test/unit/server/fresh-agent/opencode-serve-adapter.test.ts
index b35a17685..a29a7d771 100644
--- a/test/unit/server/fresh-agent/opencode-serve-adapter.test.ts
+++ b/test/unit/server/fresh-agent/opencode-serve-adapter.test.ts
@@ -12,14 +12,19 @@ function makeFakeManager() {
return e
}
return {
- createSession: vi.fn(async () => ({ id: 'ses_real_1', directory: '/repo', title: 'T' })),
+ createSession: vi.fn(async (input?: { directory?: string }) => ({
+ id: 'ses_real_1',
+ ...(input?.directory ? { directory: input.directory } : {}),
+ title: 'T',
+ })),
+ rememberSessionCwd: vi.fn(),
promptAsync: vi.fn(async () => undefined),
listMessages: vi.fn(async () => ({ messages: [], nextCursor: null })),
getMessage: vi.fn(async () => null),
getSession: vi.fn(async () => ({ id: 'ses_real_1', title: 'T', time: { updated: 5 } })),
abort: vi.fn(async () => undefined),
compact: vi.fn(async () => undefined),
- fork: vi.fn(async () => ({ id: 'ses_child_1' })),
+ fork: vi.fn(async (): Promise<{ id: string; directory?: string }> => ({ id: 'ses_child_1' })),
onceIdle: vi.fn(async () => undefined),
subscribe: vi.fn((id: string, listener: (e: unknown) => void) => {
const e = emitterFor(id)
@@ -57,7 +62,7 @@ describe('OpenCode serve adapter: create + send', () => {
parts: [{ type: 'text', text: 'reply ok' }],
model: { providerID: 'umans-ai-coding-plan', modelID: 'umans-kimi-k2.7' },
variant: 'high',
- })
+ }, { cwd: '/repo' })
expect(manager.onceIdle).toHaveBeenCalledWith('ses_real_1', expect.any(Number))
})
@@ -92,6 +97,47 @@ describe('OpenCode serve adapter: create + send', () => {
await adapter.send?.('freshopencode-cwd-1', { text: 'hi' })
expect(manager.createSession).toHaveBeenCalledTimes(1)
expect(manager.createSession).toHaveBeenLastCalledWith({ directory: '/project-x' })
+ expect(manager.promptAsync).toHaveBeenCalledWith(
+ 'ses_real_1',
+ expect.objectContaining({ parts: [{ type: 'text', text: 'hi' }] }),
+ { cwd: '/project-x' },
+ )
+ })
+
+ it('passes restored cwd when sending to an attached durable session', async () => {
+ const manager = makeFakeManager()
+ const adapter = makeAdapter(manager)
+
+ await adapter.attach?.({
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ sessionId: 'ses_attached_send',
+ cwd: '/repo/restored-worktree',
+ })
+ await adapter.send?.('ses_attached_send', { text: 'continue' })
+
+ expect(manager.promptAsync).toHaveBeenCalledWith(
+ 'ses_attached_send',
+ { parts: [{ type: 'text', text: 'continue' }] },
+ { cwd: '/repo/restored-worktree' },
+ )
+ })
+
+ it('keeps attached no-cwd sessions sendable without a route argument', async () => {
+ const manager = makeFakeManager()
+ const adapter = makeAdapter(manager)
+
+ await adapter.attach?.({
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ sessionId: 'ses_attached_nocwd',
+ })
+ await adapter.send?.('ses_attached_nocwd', { text: 'continue' })
+
+ expect(manager.promptAsync).toHaveBeenCalledWith(
+ 'ses_attached_nocwd',
+ { parts: [{ type: 'text', text: 'continue' }] },
+ )
})
it('recovers from a failed send and still processes later sends', async () => {
@@ -133,11 +179,50 @@ describe('OpenCode serve adapter: create + send', () => {
await expect(adapter.send?.('freshopencode-unhandled-1', { text: 'boom' })).rejects.toThrow('prompt rejected')
// Simulating the idle timeout rejection that would otherwise arrive later.
idleReject(new Error('idle timeout'))
- await new Promise((r) => setTimeout(r, 10))
- expect(unhandled).not.toHaveBeenCalled()
- } finally {
- process.off('unhandledRejection', unhandled)
- }
+ await new Promise((r) => setTimeout(r, 10))
+ expect(unhandled).not.toHaveBeenCalled()
+ } finally {
+ process.off('unhandledRejection', unhandled)
+ }
+ })
+
+ it('does not return to running when OpenCode emits a late message update after idle', async () => {
+ const manager = makeFakeManager()
+ const adapter = makeAdapter(manager)
+ await adapter.create({ requestId: 'late-update', sessionType: 'freshopencode', provider: 'opencode' })
+
+ const events: unknown[] = []
+ adapter.subscribe?.('freshopencode-late-update', (event) => events.push(event))
+
+ await adapter.send?.('freshopencode-late-update', { text: 'go' })
+ manager._emit('ses_real_1', {
+ kind: 'session.idle',
+ sessionId: 'ses_real_1',
+ properties: { sessionID: 'ses_real_1' },
+ raw: { type: 'session.idle', properties: { sessionID: 'ses_real_1' } },
+ })
+ manager._emit('ses_real_1', {
+ kind: 'message.updated',
+ sessionId: 'ses_real_1',
+ properties: { sessionID: 'ses_real_1', info: { id: 'msg_user_1', role: 'user' } },
+ raw: { type: 'message.updated', properties: { sessionID: 'ses_real_1' } },
+ })
+
+ expect(events).toContainEqual({
+ type: 'sdk.session.snapshot',
+ sessionId: 'freshopencode-late-update',
+ status: 'idle',
+ })
+ expect(events.at(-1)).toEqual({
+ type: 'sdk.session.changed',
+ sessionId: 'freshopencode-late-update',
+ reason: 'opencode-message',
+ })
+ await expect(adapter.getSnapshot?.({
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ threadId: 'freshopencode-late-update',
+ })).resolves.toMatchObject({ status: 'idle' })
})
it('forwards compact instructions to the serve manager', async () => {
@@ -156,38 +241,73 @@ describe('OpenCode serve adapter: history reads', () => {
{ info: { id: 'msg_assistant_1', role: 'assistant', providerID: 'umans-ai-coding-plan', modelID: 'umans-kimi-k2.7' }, parts: [{ id: 'p2', type: 'text', text: 'ok' }] },
]
+ it('remembers cwd when attaching a durable OpenCode session', async () => {
+ const manager = makeFakeManager()
+ const adapter = makeAdapter(manager)
+
+ await adapter.attach?.({
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ sessionId: 'ses_existing_cwd',
+ cwd: '/repo/from-pane',
+ })
+
+ expect(manager.rememberSessionCwd).toHaveBeenCalledWith('ses_existing_cwd', '/repo/from-pane')
+ })
+
it('getSnapshot assembles HTTP messages into the normalized transcript', async () => {
const manager = makeFakeManager()
manager.getSession = vi.fn(async () => ({ id: 'ses_real_1', title: 'Kimi chat', time: { updated: 12 } }))
manager.listMessages = vi.fn(async () => ({ messages, nextCursor: null }))
const adapter = makeAdapter(manager)
- await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1' })
+ await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1', cwd: '/repo/history' })
await expect(adapter.getSnapshot?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1' })).resolves.toMatchObject({
sessionId: 'ses_real_1', summary: 'Kimi chat', revision: 12,
turns: [{ turnId: 'msg_user_1', role: 'user', summary: 'reply ok' }, { turnId: 'msg_assistant_1', role: 'assistant', summary: 'ok' }],
})
- expect(manager.listMessages).toHaveBeenCalledWith('ses_real_1', { limit: 200 })
+ expect(manager.getSession).toHaveBeenCalledWith('ses_real_1', { cwd: '/repo/history' })
+ expect(manager.listMessages).toHaveBeenCalledWith('ses_real_1', { limit: 200 }, { cwd: '/repo/history' })
+ })
+
+ it('omits history route arguments when no cwd is known', async () => {
+ const manager = makeFakeManager()
+ manager.getSession = vi.fn(async () => ({ id: 'ses_real_1', title: 'Kimi chat', time: { updated: 12 } }))
+ manager.listMessages = vi.fn(async () => ({ messages, nextCursor: null }))
+ manager.getMessage = vi.fn(async () => messages[1])
+ const adapter = makeAdapter(manager)
+
+ await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1' })
+ await adapter.getSnapshot?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1' })
+ await adapter.getTurnPage?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1' }, { limit: 1, revision: 0 })
+ await adapter.getTurnBody?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1', turnId: 'msg_assistant_1' }, 12)
+
+ expect(manager.getSession).toHaveBeenNthCalledWith(1, 'ses_real_1')
+ expect(manager.getSession).toHaveBeenNthCalledWith(2, 'ses_real_1')
+ expect(manager.listMessages).toHaveBeenNthCalledWith(1, 'ses_real_1', { limit: 200 })
+ expect(manager.listMessages).toHaveBeenNthCalledWith(2, 'ses_real_1', { limit: 1, before: undefined })
+ expect(manager.getMessage).toHaveBeenCalledWith('ses_real_1', 'msg_assistant_1')
})
it('getTurnPage forwards cursor as before= and returns nextCursor from the header', async () => {
const manager = makeFakeManager()
manager.listMessages = vi.fn(async () => ({ messages: messages.slice(0, 1), nextCursor: 'NEXT' }))
const adapter = makeAdapter(manager)
- await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1' })
+ await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1', cwd: '/repo/history' })
const page = await adapter.getTurnPage?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1' }, { cursor: 'CUR', limit: 1, revision: 0 })
expect(page).toMatchObject({ nextCursor: 'NEXT', turns: [{ turnId: 'msg_user_1' }] })
- expect(manager.listMessages).toHaveBeenCalledWith('ses_real_1', { limit: 1, before: 'CUR' })
+ expect(manager.getSession).toHaveBeenCalledWith('ses_real_1', { cwd: '/repo/history' })
+ expect(manager.listMessages).toHaveBeenCalledWith('ses_real_1', { limit: 1, before: 'CUR' }, { cwd: '/repo/history' })
})
it('getTurnBody fetches a single message and normalizes it', async () => {
const manager = makeFakeManager()
manager.getMessage = vi.fn(async () => messages[1])
const adapter = makeAdapter(manager)
- await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1' })
+ await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1', cwd: '/repo/history' })
await expect(adapter.getTurnBody?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1', turnId: 'msg_assistant_1' }, 12)).resolves.toMatchObject({
turnId: 'msg_assistant_1', role: 'assistant', items: expect.arrayContaining([expect.objectContaining({ kind: 'text', text: 'ok' })]),
})
- expect(manager.getMessage).toHaveBeenCalledWith('ses_real_1', 'msg_assistant_1')
+ expect(manager.getMessage).toHaveBeenCalledWith('ses_real_1', 'msg_assistant_1', { cwd: '/repo/history' })
})
it('reports fork capability true and approvals/questions false', async () => {
@@ -195,7 +315,7 @@ describe('OpenCode serve adapter: history reads', () => {
manager.getSession = vi.fn(async () => ({ id: 'ses_real_1', time: { updated: 1 } }))
manager.listMessages = vi.fn(async () => ({ messages: [], nextCursor: null }))
const adapter = makeAdapter(manager)
- await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1' })
+ await adapter.attach?.({ sessionType: 'freshopencode', provider: 'opencode', sessionId: 'ses_real_1', cwd: '/repo/history' })
const snap: any = await adapter.getSnapshot?.({ sessionType: 'freshopencode', provider: 'opencode', threadId: 'ses_real_1' })
expect(snap.capabilities).toMatchObject({ fork: true, approvals: false, questions: false })
})
@@ -239,6 +359,61 @@ describe('OpenCode serve adapter: control', () => {
}
})
+ it('routes control operations through the known cwd', async () => {
+ const manager = makeFakeManager()
+ const adapter = makeAdapter(manager)
+
+ await adapter.attach?.({
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ sessionId: 'ses_known_cwd',
+ cwd: '/repo/control',
+ })
+
+ await adapter.interrupt?.('ses_known_cwd')
+ await adapter.compact?.('ses_known_cwd', { instructions: 'trim' })
+ await expect(adapter.fork?.('ses_known_cwd')).resolves.toEqual({
+ sessionId: 'ses_child_1',
+ sessionRef: { provider: 'opencode', sessionId: 'ses_child_1' },
+ })
+ await adapter.send?.('ses_child_1', { text: 'child continue' })
+
+ expect(manager.abort).toHaveBeenCalledWith('ses_known_cwd', { cwd: '/repo/control' })
+ expect(manager.compact).toHaveBeenCalledWith('ses_known_cwd', { instructions: 'trim' }, { cwd: '/repo/control' })
+ expect(manager.fork).toHaveBeenCalledWith('ses_known_cwd', { cwd: '/repo/control' })
+ expect(manager.promptAsync).toHaveBeenCalledWith(
+ 'ses_child_1',
+ expect.objectContaining({ parts: [{ type: 'text', text: 'child continue' }] }),
+ { cwd: '/repo/control' },
+ )
+ })
+
+ it('routes forked children through the returned child directory when present', async () => {
+ const manager = makeFakeManager()
+ manager.fork.mockResolvedValueOnce({ id: 'ses_child_1', directory: '/repo/child' })
+ const adapter = makeAdapter(manager)
+
+ await adapter.attach?.({
+ sessionType: 'freshopencode',
+ provider: 'opencode',
+ sessionId: 'ses_parent',
+ cwd: '/repo/parent',
+ })
+
+ await expect(adapter.fork?.('ses_parent')).resolves.toEqual({
+ sessionId: 'ses_child_1',
+ sessionRef: { provider: 'opencode', sessionId: 'ses_child_1' },
+ })
+ await adapter.send?.('ses_child_1', { text: 'child turn' })
+
+ expect(manager.fork).toHaveBeenCalledWith('ses_parent', { cwd: '/repo/parent' })
+ expect(manager.promptAsync).toHaveBeenCalledWith(
+ 'ses_child_1',
+ expect.objectContaining({ parts: [{ type: 'text', text: 'child turn' }] }),
+ { cwd: '/repo/child' },
+ )
+ })
+
it('shutdown delegates to the serve manager', async () => {
const { manager, adapter } = await materialized()
await adapter.shutdown?.()
diff --git a/test/unit/server/fresh-agent/opencode-serve-events.test.ts b/test/unit/server/fresh-agent/opencode-serve-events.test.ts
index 77366eb71..d65d3237c 100644
--- a/test/unit/server/fresh-agent/opencode-serve-events.test.ts
+++ b/test/unit/server/fresh-agent/opencode-serve-events.test.ts
@@ -82,14 +82,68 @@ describe('serveEventToSdk', () => {
}
expect(serveEventToSdk(parsed, 'ses_a')).toEqual({ type: 'sdk.session.snapshot', sessionId: 'ses_a', status: 'running' })
})
- it('maps message.part.updated to a running snapshot (drives client re-poll)', () => {
+ it('maps message.part.updated to a transcript invalidation (drives client re-poll)', () => {
const parsed: ParsedServeEvent = {
kind: 'message.part.updated',
sessionId: 'ses_a',
properties: { sessionID: 'ses_a', part: { id: 'p', type: 'text' } },
raw: { type: 'message.part.updated', properties: { sessionID: 'ses_a', part: { id: 'p', type: 'text' } } },
}
- expect(serveEventToSdk(parsed, 'ses_a')).toEqual({ type: 'sdk.session.snapshot', sessionId: 'ses_a', status: 'running' })
+ expect(serveEventToSdk(parsed, 'ses_a')).toEqual({
+ type: 'sdk.session.changed',
+ sessionId: 'ses_a',
+ reason: 'opencode-message',
+ })
+ })
+ it('maps OpenCode transcript mutation events to invalidations instead of running snapshots', () => {
+ for (const kind of ['message.part.delta', 'message.part.updated', 'message.updated', 'message.removed', 'message.part.removed']) {
+ const parsed: ParsedServeEvent = {
+ kind,
+ sessionId: 'ses_a',
+ properties: { sessionID: 'ses_a', info: { id: 'msg_1', role: 'assistant' } },
+ raw: { type: kind, properties: { sessionID: 'ses_a' } },
+ }
+
+ expect(serveEventToSdk(parsed, 'freshopencode-req-1')).toEqual({
+ type: 'sdk.session.changed',
+ sessionId: 'freshopencode-req-1',
+ reason: 'opencode-message',
+ })
+ }
+ })
+ it('maps only active OpenCode session statuses to running', () => {
+ const statusEvent = (statusType: string): ParsedServeEvent => ({
+ kind: 'session.status',
+ sessionId: 'ses_a',
+ properties: { sessionID: 'ses_a', status: { type: statusType } },
+ raw: { type: 'session.status', properties: { sessionID: 'ses_a', status: { type: statusType } } },
+ })
+
+ expect(serveEventToSdk(statusEvent('busy'), 'ses_a')).toEqual({
+ type: 'sdk.session.snapshot',
+ sessionId: 'ses_a',
+ status: 'running',
+ })
+ expect(serveEventToSdk(statusEvent('retry'), 'ses_a')).toEqual({
+ type: 'sdk.session.snapshot',
+ sessionId: 'ses_a',
+ status: 'running',
+ })
+ expect(serveEventToSdk(statusEvent('idle'), 'ses_a')).toEqual({
+ type: 'sdk.session.snapshot',
+ sessionId: 'ses_a',
+ status: 'idle',
+ })
+ expect(serveEventToSdk(statusEvent('completed'), 'ses_a')).toEqual({
+ type: 'sdk.session.changed',
+ sessionId: 'ses_a',
+ reason: 'opencode-status',
+ })
+ expect(serveEventToSdk(statusEvent('unexpected-future-status'), 'ses_a')).toEqual({
+ type: 'sdk.session.changed',
+ sessionId: 'ses_a',
+ reason: 'opencode-status',
+ })
})
it('maps session.error to an sdk.error', () => {
const parsed: ParsedServeEvent = {
diff --git a/test/unit/server/fresh-agent/opencode-serve-manager.test.ts b/test/unit/server/fresh-agent/opencode-serve-manager.test.ts
index 113f32746..f01242da2 100644
--- a/test/unit/server/fresh-agent/opencode-serve-manager.test.ts
+++ b/test/unit/server/fresh-agent/opencode-serve-manager.test.ts
@@ -58,6 +58,83 @@ describe('OpencodeServeManager lifecycle', () => {
expect(fetchFn).toHaveBeenCalledWith('http://127.0.0.1:47999/global/health', expect.anything())
})
+ it('starts the serve process in the requested session directory before creating the first session', async () => {
+ const calls: Array<{ url: string; init: any }> = []
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ calls.push({ url, init })
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true, version: '1.17.8' })
+ if (url.endsWith('/session') && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_project_x', directory: '/project-x', title: 'Project X' })
+ }
+ return jsonResponse({})
+ })
+ const { manager, spawnFn } = makeManager({ fetchFn: fetchFn as any })
+
+ const session = await manager.createSession({ directory: '/project-x' })
+
+ expect(session).toMatchObject({ id: 'ses_project_x', directory: '/project-x' })
+ expect(spawnFn).toHaveBeenCalledWith(
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '47999'],
+ expect.objectContaining({
+ cwd: '/project-x',
+ env: expect.objectContaining({ FRESHELL_OPENCODE_SIDECAR_ID: expect.any(String) }),
+ }),
+ )
+ expect(calls.find((call) => call.url.endsWith('/session'))).toMatchObject({
+ url: 'http://127.0.0.1:47999/session',
+ init: expect.objectContaining({
+ method: 'POST',
+ body: JSON.stringify({ directory: '/project-x' }),
+ }),
+ })
+ })
+
+ it('uses separate serve processes for sessions created in different directories', async () => {
+ const childA = fakeChild()
+ const childB = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childA)
+ .mockReturnValueOnce(childB)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session' && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_a', directory: '/project-a' })
+ }
+ if (url === 'http://127.0.0.1:48000/session' && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_b', directory: '/project-b' })
+ }
+ return jsonResponse({})
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await expect(manager.createSession({ directory: '/project-a' })).resolves.toMatchObject({ id: 'ses_a' })
+ await expect(manager.createSession({ directory: '/project-b' })).resolves.toMatchObject({ id: 'ses_b' })
+
+ expect(spawnFn).toHaveBeenCalledTimes(2)
+ expect(spawnFn).toHaveBeenNthCalledWith(
+ 1,
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '47999'],
+ expect.objectContaining({ cwd: '/project-a' }),
+ )
+ expect(spawnFn).toHaveBeenNthCalledWith(
+ 2,
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '48000'],
+ expect.objectContaining({ cwd: '/project-b' }),
+ )
+ })
+
it('shuts down by killing the spawned process and refuses further use until restarted', async () => {
const { manager, child } = makeManager()
await manager.ensureStarted()
@@ -99,8 +176,8 @@ describe('OpencodeServeManager lifecycle', () => {
await expect(started).rejects.toThrow(/opencode serve startup was aborted|opencode serve did not become healthy/)
await shutdown
expect(child.kill).toHaveBeenCalled()
- expect((manager as any).running).toBeUndefined()
- expect((manager as any).startPromise).toBeUndefined()
+ expect((manager as any).runningByCwd.size).toBe(0)
+ expect((manager as any).startPromiseByCwd.size).toBe(0)
})
})
@@ -182,6 +259,214 @@ describe('OpencodeServeManager HTTP client', () => {
const { manager } = makeManager({ fetchFn: fetchFn as any })
await expect(manager.getMessage('ses_x', 'broken')).rejects.toThrow(/opencode serve GET .*\/message\/broken → 500/)
})
+
+ it('posts summarize requests to a cwd sidecar learned from getSession', async () => {
+ const calls: Array<{ url: string; init: any }> = []
+ const childDefault = fakeChild()
+ const childProject = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childDefault)
+ .mockReturnValueOnce(childProject)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ calls.push({ url, init })
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_known' && init?.method === 'GET') {
+ return jsonResponse({ id: 'ses_known', directory: '/project-a', title: 'Known' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_known/compact' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/session/ses_known/summarize' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await expect(manager.getSession('ses_known')).resolves.toMatchObject({ id: 'ses_known', directory: '/project-a' })
+ await manager.compact('ses_known', { instructions: 'keep it short' })
+
+ expect(spawnFn).toHaveBeenCalledTimes(2)
+ expect(spawnFn.mock.calls[0]?.[2]).not.toHaveProperty('cwd')
+ expect(spawnFn).toHaveBeenNthCalledWith(
+ 2,
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '48000'],
+ expect.objectContaining({ cwd: '/project-a' }),
+ )
+ expect(calls.find((call) => call.url.endsWith('/summarize'))).toMatchObject({
+ url: 'http://127.0.0.1:48000/session/ses_known/summarize',
+ init: expect.objectContaining({
+ method: 'POST',
+ body: JSON.stringify({ instructions: 'keep it short' }),
+ }),
+ })
+ expect(calls.some((call) => call.url.endsWith('/compact'))).toBe(false)
+ })
+
+ it('remembers the forked child directory for later requests instead of keeping the parent route', async () => {
+ const calls: Array<{ url: string; init: any }> = []
+ const childDefault = fakeChild()
+ const childParent = fakeChild()
+ const childFork = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childDefault)
+ .mockReturnValueOnce(childParent)
+ .mockReturnValueOnce(childFork)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ calls.push({ url, init })
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_parent' && init?.method === 'GET') {
+ return jsonResponse({ id: 'ses_parent', directory: '/parent' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_parent/fork' && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_child', directory: '/child' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_child/compact' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/session/ses_parent/fork' && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_child', directory: '/child' })
+ }
+ if (url === 'http://127.0.0.1:48001/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48001/session/ses_child/summarize' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48001 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await expect(manager.getSession('ses_parent')).resolves.toMatchObject({ id: 'ses_parent', directory: '/parent' })
+ await expect(manager.fork('ses_parent')).resolves.toMatchObject({ id: 'ses_child', directory: '/child' })
+ await manager.compact('ses_child', { instructions: 'child summary' })
+
+ expect(spawnFn).toHaveBeenCalledTimes(3)
+ expect(spawnFn).toHaveBeenNthCalledWith(
+ 2,
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '48000'],
+ expect.objectContaining({ cwd: '/parent' }),
+ )
+ expect(spawnFn).toHaveBeenNthCalledWith(
+ 3,
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '48001'],
+ expect.objectContaining({ cwd: '/child' }),
+ )
+ expect(calls.find((call) => call.url.endsWith('/session/ses_child/summarize'))).toMatchObject({
+ url: 'http://127.0.0.1:48001/session/ses_child/summarize',
+ init: expect.objectContaining({
+ method: 'POST',
+ body: JSON.stringify({ instructions: 'child summary' }),
+ }),
+ })
+ })
+
+ it('falls back to the fork route cwd when the fork response omits directory', async () => {
+ const calls: Array<{ url: string; init: any }> = []
+ const childParent = fakeChild()
+ const spawnFn = vi.fn().mockReturnValueOnce(childParent)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ calls.push({ url, init })
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_parent/fork' && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_child' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_child/summarize' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ if (url.includes('/session/ses_child/summarize')) {
+ throw new Error(`child summarize should stay on parent cwd route, got ${url}`)
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await expect(manager.fork('ses_parent', { cwd: '/parent' })).resolves.toMatchObject({ id: 'ses_child' })
+ await manager.compact('ses_child', { instructions: 'child summary' })
+
+ expect(spawnFn).toHaveBeenCalledTimes(1)
+ expect(spawnFn).toHaveBeenCalledWith(
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '47999'],
+ expect.objectContaining({ cwd: '/parent' }),
+ )
+ expect(calls.find((call) => call.url.endsWith('/session/ses_child/summarize'))).toMatchObject({
+ url: 'http://127.0.0.1:47999/session/ses_child/summarize',
+ init: expect.objectContaining({ method: 'POST' }),
+ })
+ })
+
+ it('uses the default serve route for unknown existing sessions even after cwd sidecars exist', async () => {
+ const childProject = fakeChild()
+ const childDefault = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childProject)
+ .mockReturnValueOnce(childDefault)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/session' && init?.method === 'POST') {
+ return jsonResponse({ id: 'ses_project', directory: '/project-a' })
+ }
+ if (url === 'http://127.0.0.1:48000/session/ses_unknown' && init?.method === 'GET') {
+ throw new Error('unknown session lookup must not hit cwd sidecar')
+ }
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_unknown' && init?.method === 'GET') {
+ return jsonResponse({ id: 'ses_unknown', title: 'Unknown' })
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await expect(manager.createSession({ directory: '/project-a' })).resolves.toMatchObject({ id: 'ses_project' })
+ await expect(manager.getSession('ses_unknown')).resolves.toMatchObject({ id: 'ses_unknown' })
+
+ expect(spawnFn).toHaveBeenCalledTimes(2)
+ expect(spawnFn).toHaveBeenNthCalledWith(
+ 1,
+ 'opencode',
+ ['serve', '--hostname', '127.0.0.1', '--port', '48000'],
+ expect.objectContaining({ cwd: '/project-a' }),
+ )
+ expect(spawnFn.mock.calls[1]?.[2]).not.toHaveProperty('cwd')
+ expect(fetchFn).not.toHaveBeenCalledWith('http://127.0.0.1:48000/session/ses_unknown', expect.anything())
+ expect(fetchFn).toHaveBeenCalledWith('http://127.0.0.1:47999/session/ses_unknown', expect.anything())
+ })
})
describe('OpencodeServeManager fan-out', () => {
@@ -250,6 +535,194 @@ describe('OpencodeServeManager fan-out', () => {
await expect(idle).rejects.toThrow(/idle/i)
})
+ it('onceIdle resolves when status-map activity drops out of the OpenCode status map', async () => {
+ let statusCalls = 0
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) {
+ statusCalls += 1
+ return statusCalls === 1
+ ? jsonResponse({ ses_a: { type: 'busy' } })
+ : jsonResponse({})
+ }
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ const idle = manager.onceIdle('ses_a', 1000)
+
+ await expect(idle).resolves.toBeUndefined()
+ expect(fetchFn).toHaveBeenCalledWith('http://127.0.0.1:47999/session/status', expect.anything())
+ expect((manager as any).sessionEmitters.get('ses_a')?.listenerCount('event') ?? 0).toBe(0)
+ })
+
+ it('onceIdle does not resolve from status-map absence before observed OpenCode activity', async () => {
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) return jsonResponse({})
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ await expect(manager.onceIdle('ses_a', 30)).rejects.toThrow(/idle/i)
+ })
+
+ it('onceIdle ignores late message.updated events when the status map stays absent', async () => {
+ let push!: (e: any) => void
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) return jsonResponse({})
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ connectEventStream: (_url, h) => { push = (e) => h.onEvent(parseEvt(e)); return () => {} },
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ const idle = manager.onceIdle('ses_a', 30)
+ push({ type: 'message.updated', properties: { sessionID: 'ses_a', message: { id: 'old-turn' } } })
+
+ await expect(idle).rejects.toThrow(/idle/i)
+ })
+
+ it('onceIdle waits for later running status-map evidence after a late message.updated event', async () => {
+ let push!: (e: any) => void
+ let statusCalls = 0
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) {
+ statusCalls += 1
+ if (statusCalls <= 2) return jsonResponse({})
+ if (statusCalls === 3) return jsonResponse({ ses_a: { type: 'busy' } })
+ return jsonResponse({})
+ }
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ connectEventStream: (_url, h) => { push = (e) => h.onEvent(parseEvt(e)); return () => {} },
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ const idle = manager.onceIdle('ses_a', 80)
+ push({ type: 'message.updated', properties: { sessionID: 'ses_a', message: { id: 'old-turn' } } })
+
+ await expect(idle).resolves.toBeUndefined()
+ })
+
+ it('onceIdle does not resolve from a single busy signal plus one empty status-map poll', async () => {
+ let push!: (e: any) => void
+ let statusCalls = 0
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) {
+ statusCalls += 1
+ if (statusCalls === 1) return jsonResponse({})
+ throw new Error('status map unavailable')
+ }
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ connectEventStream: (_url, h) => { push = (e) => h.onEvent(parseEvt(e)); return () => {} },
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ const idle = manager.onceIdle('ses_a', 40)
+ push({ type: 'session.status', properties: { sessionID: 'ses_a', status: { type: 'busy' } } })
+
+ const pending = await Promise.race([
+ idle.then(() => 'resolved', () => 'rejected'),
+ new Promise<'pending'>((resolve) => setTimeout(() => resolve('pending'), 15)),
+ ])
+ expect(pending).toBe('pending')
+ await expect(idle).rejects.toThrow(/idle/i)
+ })
+
+ it('onceIdle warns only once per wait when status-map fallback polling keeps failing', async () => {
+ let push!: (e: any) => void
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) throw new Error('status map unavailable')
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ connectEventStream: (_url, h) => { push = (e) => h.onEvent(parseEvt(e)); return () => {} },
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ const warnSpy = vi.spyOn((manager as any).log, 'warn').mockImplementation(() => undefined)
+ const idle = manager.onceIdle('ses_a', 35)
+ push({ type: 'session.status', properties: { sessionID: 'ses_a', status: { type: 'busy' } } })
+
+ await expect(idle).rejects.toThrow(/idle/i)
+ expect(warnSpy).toHaveBeenCalledTimes(1)
+ })
+
+ it('onceIdle requires a fresh consecutive idle/absent pair after a status-map poll failure', async () => {
+ let push!: (e: any) => void
+ let statusCalls = 0
+ let allowFifthPoll!: () => void
+ let noteFifthPollStarted!: () => void
+ const fifthPollGate = new Promise((resolve) => {
+ allowFifthPoll = resolve
+ })
+ const fifthPollStarted = new Promise((resolve) => {
+ noteFifthPollStarted = resolve
+ })
+ const fetchFn = vi.fn(async (url: string) => {
+ if (url.endsWith('/global/health')) return jsonResponse({ healthy: true })
+ if (url.endsWith('/session/status')) {
+ statusCalls += 1
+ if (statusCalls === 1) return jsonResponse({ ses_a: { type: 'busy' } })
+ if (statusCalls === 2) return jsonResponse({})
+ if (statusCalls === 3) throw new Error('status map unavailable')
+ if (statusCalls === 4) return jsonResponse({})
+ if (statusCalls === 5) {
+ noteFifthPollStarted()
+ await fifthPollGate
+ return jsonResponse({})
+ }
+ return jsonResponse({})
+ }
+ return jsonResponse({})
+ })
+ const { manager } = makeManager({
+ fetchFn: fetchFn as any,
+ connectEventStream: (_url, h) => { push = (e) => h.onEvent(parseEvt(e)); return () => {} },
+ idlePollMs: 5,
+ })
+ await manager.ensureStarted()
+
+ const idle = manager.onceIdle('ses_a', 100)
+ push({ type: 'session.status', properties: { sessionID: 'ses_a', status: { type: 'busy' } } })
+
+ await fifthPollStarted
+ const pending = await Promise.race([
+ idle.then(() => 'resolved', () => 'rejected'),
+ new Promise<'pending'>((resolve) => setTimeout(() => resolve('pending'), 15)),
+ ])
+ expect(pending).toBe('pending')
+
+ allowFifthPoll()
+ await expect(idle).resolves.toBeUndefined()
+ expect(statusCalls).toBe(5)
+ }, 1000)
+
it('onceIdle rejects on timeout', async () => {
const { manager } = makeManager({ connectEventStream: () => () => {} })
await manager.ensureStarted()
@@ -290,7 +763,142 @@ describe('OpencodeServeManager fan-out', () => {
expect(stopStream).toHaveBeenCalled()
expect(child.kill).toHaveBeenCalled()
expect((manager as any).sessionEmitters.size).toBe(0)
- expect((manager as any).running).toBeUndefined()
+ expect((manager as any).runningByCwd.size).toBe(0)
+ })
+
+ it('default sidecar close clears unmapped emitters but preserves mapped cwd sessions', async () => {
+ const childDefault = fakeChild()
+ const childProject = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childDefault)
+ .mockReturnValueOnce(childProject)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_project' && init?.method === 'GET') {
+ return jsonResponse({ id: 'ses_project', directory: '/project-a' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_project/compact' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/session/ses_project/summarize' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await manager.ensureStarted()
+ manager.subscribe('ses_default', () => {})
+ await manager.getSession('ses_project')
+ await manager.compact('ses_project')
+ manager.subscribe('ses_project', () => {})
+ expect(spawnFn).toHaveBeenCalledTimes(2)
+
+ childDefault.emit('close', 1)
+
+ expect((manager as any).sessionEmitters.has('ses_default')).toBe(false)
+ expect((manager as any).sessionEmitters.has('ses_project')).toBe(true)
+ })
+
+ it('non-default sidecar close removes its mapped emitter and preserves unrelated default emitters', async () => {
+ const childDefault = fakeChild()
+ const childProject = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childDefault)
+ .mockReturnValueOnce(childProject)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_project' && init?.method === 'GET') {
+ return jsonResponse({ id: 'ses_project', directory: '/project-a' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_project/compact' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/session/ses_project/summarize' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ })
+
+ await manager.ensureStarted()
+ manager.subscribe('ses_default', () => {})
+ await manager.getSession('ses_project')
+ await manager.compact('ses_project')
+ manager.subscribe('ses_project', () => {})
+ expect(spawnFn).toHaveBeenCalledTimes(2)
+ expect((manager as any).sessionEmitters.has('ses_default')).toBe(true)
+ expect((manager as any).sessionEmitters.has('ses_project')).toBe(true)
+
+ childProject.emit('close', 1)
+
+ expect((manager as any).sessionEmitters.has('ses_project')).toBe(false)
+ expect((manager as any).sessionEmitters.has('ses_default')).toBe(true)
+ })
+
+ it('idles out cwd sidecars without stopping the default serve', async () => {
+ vi.useFakeTimers()
+ try {
+ const childDefault = fakeChild()
+ const childProject = fakeChild()
+ const spawnFn = vi.fn()
+ .mockReturnValueOnce(childDefault)
+ .mockReturnValueOnce(childProject)
+ const fetchFn = vi.fn(async (url: string, init: any) => {
+ if (url === 'http://127.0.0.1:47999/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:47999/session/ses_project' && init?.method === 'GET') {
+ return jsonResponse({ id: 'ses_project', directory: '/project-a' })
+ }
+ if (url === 'http://127.0.0.1:47999/session/ses_project/compact' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ if (url === 'http://127.0.0.1:48000/global/health') return jsonResponse({ healthy: true })
+ if (url === 'http://127.0.0.1:48000/session/ses_project/summarize' && init?.method === 'POST') {
+ return jsonResponse({}, { status: 204 })
+ }
+ return jsonResponse({}, { status: 404 })
+ })
+ const manager = new OpencodeServeManager({
+ spawnFn: spawnFn as any,
+ fetchFn: fetchFn as any,
+ allocatePort: vi.fn()
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 47999 })
+ .mockResolvedValueOnce({ hostname: '127.0.0.1', port: 48000 }),
+ connectEventStream: () => () => {},
+ healthTimeoutMs: 1000,
+ idleShutdownMs: 50,
+ } as any)
+
+ await manager.ensureStarted()
+ await manager.getSession('ses_project')
+ await manager.compact('ses_project')
+ expect(spawnFn).toHaveBeenCalledTimes(2)
+
+ await vi.advanceTimersByTimeAsync(51)
+
+ expect(childProject.kill).toHaveBeenCalled()
+ expect(childDefault.kill).not.toHaveBeenCalled()
+ } finally {
+ vi.useRealTimers()
+ }
})
it('parses multi-line SSE data blocks by joining data: lines', async () => {
diff --git a/test/unit/server/fresh-agent/production-wiring.test.ts b/test/unit/server/fresh-agent/production-wiring.test.ts
index d388db93c..a0c6db7f9 100644
--- a/test/unit/server/fresh-agent/production-wiring.test.ts
+++ b/test/unit/server/fresh-agent/production-wiring.test.ts
@@ -14,6 +14,8 @@ describe('fresh-agent production wiring', () => {
expect(source).toContain('registerFreshAgentThreadRoutes')
expect(source).toContain('createClaudeFreshAgentAdapter')
expect(source).toContain('createCodexFreshAgentAdapter')
+ expect(source).toContain('getCodexDisplayIdSecret')
+ expect(source).toMatch(/displayIdSecret:\s*codexDisplayIdSecret/)
expect(source).toContain('createOpencodeFreshAgentAdapter')
expect(source).toMatch(/const freshAgentRuntimeManager = new FreshAgentRuntimeManager\(/)
expect(source).toMatch(/freshAgentRuntimeManager,\s*\n/)
diff --git a/test/unit/server/fresh-agent/router.test.ts b/test/unit/server/fresh-agent/router.test.ts
index 93eaf52f0..edd7e0b08 100644
--- a/test/unit/server/fresh-agent/router.test.ts
+++ b/test/unit/server/fresh-agent/router.test.ts
@@ -2,9 +2,67 @@ import { describe, expect, it, vi } from 'vitest'
import express from 'express'
import request from 'supertest'
+import { createCodexFreshAgentAdapter } from '../../../../server/fresh-agent/adapters/codex/adapter.js'
+import { FreshAgentProviderRegistry } from '../../../../server/fresh-agent/provider-registry.js'
import { createFreshAgentRouter } from '../../../../server/fresh-agent/router.js'
import { FreshAgentRuntimeManager, FreshAgentStaleThreadRevisionError } from '../../../../server/fresh-agent/runtime-manager.js'
+function makeCodexThread(id: string, turns: unknown[] = []) {
+ return {
+ id,
+ sessionId: id,
+ preview: 'Codex summary',
+ ephemeral: false,
+ modelProvider: 'openai',
+ createdAt: 1770000000,
+ updatedAt: 7,
+ status: { type: 'idle' },
+ cwd: '/repo',
+ cliVersion: 'codex-cli 0.129.0',
+ source: 'appServer',
+ turns,
+ }
+}
+
+function makeMixedCodexTurn(id: string) {
+ return {
+ id,
+ status: 'completed',
+ items: [
+ {
+ type: 'userMessage',
+ id: `${id}:user`,
+ content: [{ type: 'text', text: 'Review the diff.' }],
+ },
+ {
+ type: 'reasoning',
+ id: `${id}:reasoning`,
+ summary: ['Checking changes'],
+ content: [],
+ },
+ {
+ type: 'agentMessage',
+ id: `${id}:assistant`,
+ text: 'The patch is safe.',
+ },
+ ],
+ }
+}
+
+function makeCodexTurn(id: string) {
+ return {
+ id,
+ status: 'completed',
+ items: [{
+ type: 'agentMessage',
+ id: `${id}:item-1`,
+ text: 'Codex summary',
+ phase: null,
+ memoryCitation: null,
+ }],
+ }
+}
+
describe('fresh-agent router', () => {
it('returns 409 for stale thread revisions instead of mixing bodies from different revisions', async () => {
const manager = {
@@ -21,4 +79,114 @@ describe('fresh-agent router', () => {
expect(response.body.code).toBe('STALE_THREAD_REVISION')
expect(response.body.currentRevision).toBe(7)
})
+
+ it('serves Freshcodex split display turns and maps Codex boundary errors intentionally', async () => {
+ const durableTurn = makeMixedCodexTurn('turn-1')
+ const runtime = {
+ startThread: vi.fn(),
+ resumeThread: vi.fn(),
+ readThread: vi.fn().mockResolvedValue({
+ thread: makeCodexThread('thread-new-1', [durableTurn]),
+ }),
+ listThreadTurns: vi.fn().mockResolvedValue({
+ revision: 7,
+ nextCursor: null,
+ turns: [durableTurn],
+ }),
+ readThreadTurn: vi.fn().mockResolvedValue(durableTurn),
+ }
+ const adapter = createCodexFreshAgentAdapter({
+ displayIdSecret: 'router-task-4-secret',
+ runtime: runtime as any,
+ })
+ const registry = new FreshAgentProviderRegistry([{
+ sessionType: 'freshcodex',
+ runtimeProvider: 'codex',
+ adapter,
+ }])
+ const runtimeManager = new FreshAgentRuntimeManager({ registry })
+ const app = express()
+ app.use('/api', createFreshAgentRouter({ runtimeManager }))
+
+ const snapshot = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1')
+ .expect(200)
+ expect(snapshot.body.turns).toHaveLength(2)
+ expect(snapshot.body.turns.map((turn: any) => turn.role)).toEqual(['user', 'assistant'])
+ expect(JSON.stringify(snapshot.body)).not.toContain('providerTurnId')
+
+ const firstPage = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns?revision=7&limit=1')
+ .expect(200)
+ expect(firstPage.body.turns).toHaveLength(1)
+ expect(firstPage.body.turns[0]).toMatchObject({ role: 'user' })
+ expect(firstPage.body.nextCursor).toMatch(/^codex-cursor:v1:/)
+ expect(JSON.stringify(firstPage.body)).not.toContain('providerTurnId')
+
+ const secondPage = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns')
+ .query({ revision: '7', limit: '1', cursor: firstPage.body.nextCursor })
+ .expect(200)
+ expect(secondPage.body.turns).toHaveLength(1)
+ expect(secondPage.body.turns[0]).toMatchObject({ role: 'assistant' })
+ expect(JSON.stringify(secondPage.body)).not.toContain('providerTurnId')
+
+ const body = await request(app)
+ .get(`/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns/${encodeURIComponent(secondPage.body.turns[0].turnId)}?revision=7`)
+ .expect(200)
+ expect(body.body).toMatchObject({
+ turnId: secondPage.body.turns[0].turnId,
+ role: 'assistant',
+ threadId: 'thread-new-1',
+ revision: 7,
+ })
+ expect(runtime.readThreadTurn).toHaveBeenCalledWith({
+ threadId: 'thread-new-1',
+ turnId: 'turn-1',
+ revision: 7,
+ })
+ expect(JSON.stringify(body.body)).not.toContain('providerTurnId')
+
+ runtime.readThreadTurn.mockResolvedValueOnce(makeCodexTurn('turn-1'))
+ const unprovableBody = await request(app)
+ .get(`/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns/${encodeURIComponent(secondPage.body.turns[0].turnId)}?revision=7`)
+ .expect(409)
+ expect(unprovableBody.body.code).toBe('UNPROVABLE_THREAD_REVISION')
+ expect(unprovableBody.body.requestedRevision).toBe(7)
+
+ const malformedCursor = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns?revision=7&cursor=bad-cursor')
+ .expect(400)
+ expect(malformedCursor.body.code).toBe('INVALID_TURN_CURSOR')
+
+ const malformedDisplayId = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns/codex-display:v1:not-a-valid-envelope?revision=7')
+ .expect(400)
+ expect(malformedDisplayId.body.code).toBe('INVALID_DISPLAY_ID')
+
+ runtime.listThreadTurns.mockResolvedValueOnce({
+ revision: 9,
+ nextCursor: null,
+ turns: [durableTurn],
+ })
+ const staleRevision = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns/codex-display:v1:abcdefghijklmnopqrstu1?revision=7')
+ .expect(409)
+ expect(staleRevision.body.code).toBe('STALE_THREAD_REVISION')
+
+ const ambiguousNativeId = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns/turn-1?revision=7')
+ .expect(409)
+ expect(ambiguousNativeId.body.code).toBe('AMBIGUOUS_NATIVE_TURN_ID')
+
+ runtime.listThreadTurns.mockResolvedValueOnce({
+ revision: 7,
+ nextCursor: null,
+ turns: [durableTurn],
+ })
+ const exactMiss = await request(app)
+ .get('/api/fresh-agent/threads/freshcodex/codex/thread-new-1/turns/codex-display:v1:abcdefghijklmnopqrstu1?revision=7')
+ .expect(404)
+ expect(exactMiss.body.code).toBe('TURN_NOT_FOUND')
+ })
})
diff --git a/test/unit/server/terminal-registry.codex-sidecar.test.ts b/test/unit/server/terminal-registry.codex-sidecar.test.ts
index 4220c6c24..114ba82e2 100644
--- a/test/unit/server/terminal-registry.codex-sidecar.test.ts
+++ b/test/unit/server/terminal-registry.codex-sidecar.test.ts
@@ -29,6 +29,7 @@ const mockPtyProcess = vi.hoisted(() => {
emitter.emit('exit', { exitCode: 0 })
}
}),
+ _emitData: (data: string) => emitter.emit('data', data),
_emitExit: (exitCode: number, signal?: number) => emitter.emit('exit', { exitCode, signal }),
}
return pty
@@ -270,6 +271,40 @@ describe('TerminalRegistry Codex sidecar ownership', () => {
})
})
+ it('allows Codex update prompt menu replies while restore identity is pending', () => {
+ const registry = new TerminalRegistry()
+ const term = registry.create({
+ mode: 'codex',
+ providerSettings: {
+ codexAppServer: {
+ wsUrl: 'ws://127.0.0.1:43123',
+ sidecar: createFakeSidecar(),
+ },
+ } as any,
+ })
+
+ const pty = mockPtyProcess.instances[0]
+ pty._emitData([
+ '\x1b[1mUpdate available! 0.140.0 -> 0.141.0\x1b[0m\r\n',
+ 'Release notes: https://github.com/openai/codex/releases/latest\r\n',
+ '\r\n',
+ '> 1. Update now (runs `npm install -g @openai/codex`)\r\n',
+ ' 2. Skip\r\n',
+ ' 3. Skip until next version\r\n',
+ '\r\n',
+ 'Press enter to continue\r\n',
+ ].join(''))
+
+ expect(registry.input(term.terminalId, '2')).toEqual({ status: 'written' })
+ expect(pty.write).toHaveBeenLastCalledWith('2')
+ expect(registry.input(term.terminalId, '\r')).toEqual({ status: 'written' })
+ expect(pty.write).toHaveBeenLastCalledWith('\r')
+ expect(registry.input(term.terminalId, 'hello\r')).toEqual({
+ status: 'blocked_codex_identity_pending',
+ terminalId: term.terminalId,
+ })
+ })
+
it('keeps reporting the Codex identity capture timeout after closing the failed terminal', async () => {
const registry = new TerminalRegistry()
const sidecar = createFakeSidecar()
diff --git a/test/unit/server/ws-fresh-agent-contract.test.ts b/test/unit/server/ws-fresh-agent-contract.test.ts
index aaadb578c..4999b8db5 100644
--- a/test/unit/server/ws-fresh-agent-contract.test.ts
+++ b/test/unit/server/ws-fresh-agent-contract.test.ts
@@ -33,6 +33,16 @@ describe('fresh-agent websocket contract', () => {
tool: { name: 'Bash', input: { command: 'npm test' } },
})
+ expect(normalizeFreshAgentProviderEvent({
+ type: 'sdk.session.changed',
+ sessionId: 's1',
+ reason: 'opencode-status',
+ })).toEqual({
+ type: 'freshAgent.session.changed',
+ sessionId: 's1',
+ reason: 'opencode-status',
+ })
+
expect(normalizeFreshAgentProviderEvent({
type: 'freshAgent.status',
sessionId: 's1',
diff --git a/test/unit/server/ws-handler-fresh-agent.test.ts b/test/unit/server/ws-handler-fresh-agent.test.ts
index a82e06264..479ebe3f1 100644
--- a/test/unit/server/ws-handler-fresh-agent.test.ts
+++ b/test/unit/server/ws-handler-fresh-agent.test.ts
@@ -368,7 +368,7 @@ describe('WsHandler fresh-agent routing', () => {
runtimeProvider: 'codex',
}),
subscribe: vi.fn().mockResolvedValue(() => undefined),
- send: vi.fn().mockResolvedValue(undefined),
+ send: vi.fn().mockResolvedValue({ requestId: 'send-req-1', submittedTurnId: 'display-user-1' }),
interrupt: vi.fn().mockResolvedValue(undefined),
resolveApproval: vi.fn().mockResolvedValue(undefined),
answerQuestion: vi.fn().mockResolvedValue(undefined),
@@ -397,6 +397,7 @@ describe('WsHandler fresh-agent routing', () => {
ws.send(JSON.stringify({
type: 'freshAgent.send',
+ requestId: 'send-req-1',
sessionId: 'codex-session-2',
sessionType: 'freshcodex',
provider: 'codex',
@@ -442,6 +443,7 @@ describe('WsHandler fresh-agent routing', () => {
await vi.waitFor(() => {
const locator = { sessionId: 'codex-session-2', sessionType: 'freshcodex', provider: 'codex' }
expect(runtimeManager.send).toHaveBeenCalledWith(locator, {
+ requestId: 'send-req-1',
text: 'Ship it',
images: undefined,
settings: { cwd: '/repo', model: 'gpt-5.4-mini', effort: 'low' },
@@ -455,6 +457,11 @@ describe('WsHandler fresh-agent routing', () => {
expect.any(Function),
)
expect(runtimeManager.kill).toHaveBeenCalledWith(locator)
+ expect(seenMessages).toContainEqual(expect.objectContaining({
+ type: 'freshAgent.send.accepted',
+ requestId: 'send-req-1',
+ submittedTurnId: 'display-user-1',
+ }))
expect(seenMessages).toContainEqual(expect.objectContaining({
type: 'freshAgent.forked',
requestId: 'fork-req-1',
@@ -670,6 +677,7 @@ describe('WsHandler fresh-agent routing', () => {
sessionType: 'freshclaude',
provider: 'claude',
resumeSessionId: 'cli-session-attached',
+ cwd: '/repo/restored-worktree',
}))
await vi.waitFor(() => {
@@ -677,14 +685,25 @@ describe('WsHandler fresh-agent routing', () => {
sessionId: 'claude-session-attached',
sessionType: 'freshclaude',
provider: 'claude',
+ cwd: '/repo/restored-worktree',
})
expect(runtimeManager.subscribe).toHaveBeenCalledWith(
- { sessionId: 'claude-session-attached', sessionType: 'freshclaude', provider: 'claude' },
+ {
+ sessionId: 'claude-session-attached',
+ sessionType: 'freshclaude',
+ provider: 'claude',
+ cwd: '/repo/restored-worktree',
+ },
expect.any(Function),
)
})
- listeners.get(JSON.stringify({ sessionId: 'claude-session-attached', sessionType: 'freshclaude', provider: 'claude' }))?.({ kind: 'thread.updated', revision: 2 })
+ listeners.get(JSON.stringify({
+ sessionId: 'claude-session-attached',
+ sessionType: 'freshclaude',
+ provider: 'claude',
+ cwd: '/repo/restored-worktree',
+ }))?.({ kind: 'thread.updated', revision: 2 })
await vi.waitFor(() => {
expect(seenMessages).toContainEqual({
diff --git a/test/unit/shared/fresh-agent-models.test.ts b/test/unit/shared/fresh-agent-models.test.ts
index 225ab2587..745c8e482 100644
--- a/test/unit/shared/fresh-agent-models.test.ts
+++ b/test/unit/shared/fresh-agent-models.test.ts
@@ -8,8 +8,38 @@ import {
} from '@shared/fresh-agent-models'
describe('fresh-agent-models freshopencode options', () => {
+ const GLM_5_2_MODEL = 'opencode-go/glm-5.2'
const KIMI_K2_7_MODEL = 'umans-ai-coding-plan/umans-kimi-k2.7'
+ it('includes GLM 5.2 as a selectable Freshopencode model', () => {
+ const option = resolveFreshAgentModelOption('freshopencode', GLM_5_2_MODEL)
+
+ expect(option).toMatchObject({
+ value: GLM_5_2_MODEL,
+ label: 'GLM 5.2',
+ thinkingEfforts: ['minimal', 'low', 'medium', 'high', 'max'],
+ defaultEffort: 'max',
+ })
+ })
+
+ it('normalizes the GLM 5.2 model value for the opencode runtime provider', () => {
+ const normalized = normalizeFreshAgentModel('freshopencode', 'opencode', GLM_5_2_MODEL)
+
+ expect(normalized).toBe(GLM_5_2_MODEL)
+ })
+
+ it('exposes the expected thinking levels for GLM 5.2', () => {
+ const options = getFreshAgentThinkingOptions('freshopencode', 'opencode', GLM_5_2_MODEL)
+
+ expect(options.map((o) => o.value)).toEqual(['minimal', 'low', 'medium', 'high', 'max'])
+ })
+
+ it('lists GLM 5.2 in the static Freshopencode options array', () => {
+ const values = FRESH_AGENT_MODEL_OPTIONS_BY_SESSION_TYPE.freshopencode.map((o) => o.value)
+
+ expect(values).toContain(GLM_5_2_MODEL)
+ })
+
it('includes Kimi k2.7 as a selectable Freshopencode model', () => {
const option = resolveFreshAgentModelOption('freshopencode', KIMI_K2_7_MODEL)
diff --git a/test/unit/shared/fresh-agent-turns.test.ts b/test/unit/shared/fresh-agent-turns.test.ts
new file mode 100644
index 000000000..94bdf0f62
--- /dev/null
+++ b/test/unit/shared/fresh-agent-turns.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'vitest'
+
+import { FreshAgentTurnSchema } from '../../../shared/fresh-agent-contract.js'
+import {
+ freshAgentSnapshotHasUserTurn,
+ freshAgentTurnText,
+ getFreshAgentDisplayTurnKey,
+} from '../../../shared/fresh-agent-turns.js'
+
+describe('fresh-agent display turn helpers', () => {
+ it('prefers turnId over id for display keys', () => {
+ expect(getFreshAgentDisplayTurnKey({ turnId: 'turn-1', id: 'id-1' })).toBe('turn-1')
+ expect(getFreshAgentDisplayTurnKey({ turnId: 'turn-2', id: 'id-2' })).toBe('turn-2')
+ })
+
+ it('falls back to id when turnId is missing', () => {
+ expect(getFreshAgentDisplayTurnKey({ turnId: undefined as unknown as string, id: 'id-fallback' })).toBe('id-fallback')
+ })
+
+ it('joins text items and falls back to summary when no text item exists', () => {
+ expect(freshAgentTurnText({
+ summary: 'fallback',
+ items: [
+ { id: 'a', kind: 'text', text: 'hello' },
+ { id: 'b', kind: 'reasoning', summary: ['ignore'], content: ['ignore'], text: 'ignore' },
+ { id: 'c', kind: 'text', text: 'world' },
+ ],
+ })).toBe('hello world')
+
+ expect(freshAgentTurnText({
+ summary: 'fallback text',
+ items: [{ id: 'x', kind: 'thinking', text: 'ignored' }],
+ })).toBe('fallback text')
+
+ expect(freshAgentTurnText({
+ summary: 'fallback text',
+ items: [{ id: 'y', kind: 'text', text: '' }],
+ })).toBe('')
+ })
+
+ it('returns true only for normalized user turns', () => {
+ expect(freshAgentSnapshotHasUserTurn({
+ turns: [
+ { turnId: '1', id: '1', summary: 'user prompt', role: 'user', items: [] },
+ { turnId: '2', id: '2', summary: 'assistant response', role: 'assistant', items: [] },
+ ],
+ })).toBe(true)
+
+ expect(freshAgentSnapshotHasUserTurn({ turns: [] })).toBe(false)
+ expect(freshAgentSnapshotHasUserTurn({
+ turns: [{ turnId: '3', id: '3', summary: 'tool', role: 'tool', items: [] }],
+ })).toBe(false)
+
+ expect(freshAgentSnapshotHasUserTurn({
+ turns: [{ turnId: '4', id: '4', summary: 'legacy user value', role: 'USER' as unknown as string, items: [] }],
+ })).toBe(true)
+
+ expect(freshAgentSnapshotHasUserTurn({
+ turns: [{ turnId: '5', id: '5', summary: 'normalized user', role: 'USER', items: [] }],
+ })).toBe(true)
+ })
+
+ it('does not treat assistant quoted prompt text as user submissions', () => {
+ expect(freshAgentSnapshotHasUserTurn({
+ turns: [{
+ turnId: '6',
+ id: '6',
+ summary: 'assistant turn',
+ role: 'assistant',
+ items: [{ id: 'a', kind: 'text', text: 'user: hi there' }],
+ }],
+ })).toBe(false)
+ })
+
+ it('supports legacy calls with null or undefined snapshots', () => {
+ expect(freshAgentSnapshotHasUserTurn(null)).toBe(false)
+ expect(freshAgentSnapshotHasUserTurn(undefined)).toBe(false)
+ })
+
+ it('keeps FreshAgentTurnSchema unchanged and rejects providerTurnId', () => {
+ expect(() => FreshAgentTurnSchema.parse({
+ id: '1',
+ turnId: 't-1',
+ summary: 'summary',
+ items: [],
+ providerTurnId: 'legacy-id',
+ })).toThrow()
+ })
+})
diff --git a/test/unit/shared/settings.test.ts b/test/unit/shared/settings.test.ts
index 8ba057025..284e81f7b 100644
--- a/test/unit/shared/settings.test.ts
+++ b/test/unit/shared/settings.test.ts
@@ -208,13 +208,35 @@ describe('shared settings contract', () => {
expect(merged.freshAgent.providers.freshclaude?.style).toBe('sans')
})
+ it('accepts mono as a fresh-agent provider style default', () => {
+ const parsed = buildServerSettingsPatchSchema().parse({
+ freshAgent: {
+ providers: {
+ freshcodex: { style: 'mono' },
+ },
+ },
+ })
+
+ expect(parsed.freshAgent?.providers?.freshcodex).toEqual({ style: 'mono' })
+
+ const merged = mergeServerSettings(createDefaultServerSettings({ loggingDebug: false }), {
+ freshAgent: {
+ providers: {
+ freshcodex: { style: 'mono' },
+ },
+ },
+ })
+
+ expect(merged.freshAgent.providers.freshcodex?.style).toBe('mono')
+ })
+
it('rejects invalid fresh-agent provider style defaults', () => {
const schema = buildServerSettingsPatchSchema()
expect(schema.safeParse({
freshAgent: {
providers: {
- freshcodex: { style: 'mono' },
+ freshcodex: { style: 'script' },
},
},
}).success).toBe(false)
@@ -222,7 +244,7 @@ describe('shared settings contract', () => {
const merged = mergeServerSettings(createDefaultServerSettings({ loggingDebug: false }), {
freshAgent: {
providers: {
- freshcodex: { style: 'mono' as any },
+ freshcodex: { style: 'script' as any },
},
},
})