test: align e2e clients with enqueue acknowledgements

examples/headless-agent/tests/keyless-smoke.e2e.ts

@@ -40,12 +40,9 @@ describe('headless-agent keyless smoke', () => {
     expect(JSON.stringify(toolResult)).toContain('CLI_TOOL_ROUND_TRIP')
     expect(result).toMatchObject({
       type: 'result',
-      success: true,
-      turn: 1,
-      reason: { kind: 'completed' },
       usage: { inputTokens: 18, outputTokens: 8, cacheReadTokens: 2, reasoningTokens: 1 },
     })
-    expect(String(result?.['result'])).toContain('CLI_TOOL_ROUND_TRIP')
+    expect(String(result?.['output'])).toContain('CLI_TOOL_ROUND_TRIP')
     expect(persistedHeader).toMatchObject({ type: 'session' })
   }, LOADER_SMOKE_TEST_TIMEOUT_MS)
 })

examples/jsonrpc-agent/tests/keyless-smoke.e2e.ts

@@ -47,10 +47,10 @@ function waitForLine(
 
 describe('jsonrpc-agent keyless smoke', () => {
   it.each([
-    { label: 'accepts max-token results by default', envValue: undefined, expectedStatus: 'ok' },
-    { label: 'accepts max-token results when enabled through env', envValue: 'true', expectedStatus: 'ok' },
-    { label: 'reports max-token results as errors when disabled through env', envValue: 'false', expectedStatus: 'error' },
-  ])('$label', async ({ envValue, expectedStatus }) => {
+    { label: 'reports max-token turns with the default mapping config', envValue: undefined },
+    { label: 'reports max-token turns with mapping enabled through env', envValue: 'true' },
+    { label: 'reports max-token turns with mapping disabled through env', envValue: 'false' },
+  ])('$label', async ({ envValue }) => {
     const root = await mkdtemp(join(tmpdir(), 'dsh-jsonrpc-agent-smoke-'))
     const modelRequests: Record<string, unknown>[] = []
     const modelServer = createServer((request, response) => {
@@ -120,18 +120,29 @@ describe('jsonrpc-agent keyless smoke', () => {
         method: 'session/prompt',
         params: { sessionId: 'main', contentBlocks: [{ type: 'text', text: 'inspect tools' }] },
       })}\n`)
-      const finished = await waitForLine(lines, value => value.method === 'session.finished', () => stderr)
-      expect(finished).toMatchObject({
+      const prompt = await waitForLine(lines, value => value.id === 2, () => stderr)
+      expect(prompt).toMatchObject({
         jsonrpc: '2.0',
-        method: 'session.finished',
+        id: 2,
+        result: { messageId: expect.any(String) as unknown },
+      })
+      const turnEnd = await waitForLine(lines, (value) => {
+        if (value.method !== 'session.event') return false
+        const params = value.params as Record<string, unknown> | undefined
+        const event = params?.event as Record<string, unknown> | undefined
+        return params?.sessionId === 'main' && event?.type === 'turn/end'
+      }, () => stderr)
+      expect(turnEnd).toMatchObject({
+        jsonrpc: '2.0',
+        method: 'session.event',
         params: {
           sessionId: 'main',
-          status: expectedStatus,
-          reason: { kind: 'max-tokens' },
+          event: {
+            type: 'turn/end',
+            data: { reason: { kind: 'max-tokens' } },
+          },
         },
       })
-      const prompt = await waitForLine(lines, value => value.id === 2, () => stderr)
-      expect(prompt).toMatchObject({ jsonrpc: '2.0', id: 2, result: { accepted: true } })
       const tools = modelRequests[0]?.tools as { function?: { name?: string } }[]
       expect(modelRequests[0]?.max_tokens).toBe(1234)
       expect(tools.map(tool => tool.function?.name).sort()).toEqual([

packages/examples/cli-demo/tests/built-bin.e2e.ts

@@ -161,14 +161,14 @@ describe.skipIf(!existsSync(cliBin))('dsh-cli-demo BUILT bin', () => {
 
     const json = await runBuiltBin(consumer, ['--config', './cordis.yml', '--output-format', 'json', 'json task'])
     expect(JSON.parse(json.stdout)).toMatchObject({
-      type: 'result', success: true, result: 'BUILT: json task', reason: { kind: 'completed' },
+      type: 'result', output: 'BUILT: json task',
       usage: { inputTokens: 4, outputTokens: 2 },
     })
 
     const stream = await runBuiltBin(consumer, ['--config', './cordis.yml', '--output-format', 'stream-json', 'stream task'])
     const lines = stream.stdout.trimEnd().split('\n').map(line => JSON.parse(line) as Record<string, unknown>)
     expect(lines[0]).toMatchObject({ type: 'session_event', event: { type: 'turn/start' } })
-    expect(lines.at(-1)).toMatchObject({ type: 'result', success: true, result: 'BUILT: stream task' })
+    expect(lines.at(-1)).toMatchObject({ type: 'result', output: 'BUILT: stream task' })
     const sessionsRoot = join(consumer, '.sessions')
     const files = await readdir(sessionsRoot, { recursive: true })
     const logs = files.filter(file => file.endsWith('.jsonl.zstd'))
@@ -205,7 +205,7 @@ describe.skipIf(!existsSync(cliBin))('dsh-cli-demo BUILT bin', () => {
       )
       expect(result, JSON.stringify(result)).toMatchObject({ code, signal: null })
       expect(result.stdout).toContain('"kind":"aborted"')
-      expect(result.stderr).toContain('turn 1 was aborted')
+      expect(result.stderr).toBe(`dsh-cli-demo: received ${signal}\n`)
     }, 30_000)
   })
 })

packages/goal/goal/tests/goal.e2e.ts

@@ -44,10 +44,9 @@ describe('goal domain through a real cordis.yml and headless process', () => {
     const result = JSON.parse(stdout) as Record<string, unknown>
     expect(result).toMatchObject({
       type: 'result',
-      success: true,
     })
-    expect(result['result']).toBeTypeOf('string')
-    expect(result['result']).toContain('CLI tool round trip complete')
+    expect(result['output']).toBeTypeOf('string')
+    expect(result['output']).toContain('CLI tool round trip complete')
     expect(events.filter(event => event.type === 'turn/end')).toHaveLength(1)
 
     const contexts = events.filter(event => event.type === 'user/message'

packages/session-persistence/session-checkpoint-policy/tests/crash-recovery.e2e.ts

@@ -85,6 +85,7 @@ describe.skipIf(process.platform === 'win32')('semantic checkpoint hard-crash re
     expect(crashed.markerText).toBe('request-dispatched')
     const events = await load(crashed.root)
     expect(events.map(event => event.type)).toEqual([
+      'agent/inbox/spliced', 'agent/inbox/spliced',
       'turn/start', 'user/message', 'step/start', 'request/header', 'step/end', 'turn/end',
     ])
     expect(events.at(-1)).toMatchObject({