kimaki 0.26.0 → 0.28.0

package/dist/session-handler/event-stream-state.test.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { describe, expect, test } from 'vitest';
 import {} from './opencode-session-event-log.js';
-import { derivePendingPermissionRequests, getAssistantMessageIdsForLatestUserTurn, getDerivedSubagentSessions, getEventBufferSessionId, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, getLatestTurnTokenUsage, getIdleTokenUsageDelta, hasAssistantMessageCompletedBefore, doesLatestUserTurnHaveNaturalCompletion, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, isSessionBusy, } from './event-stream-state.js';
+import { derivePendingPermissionRequests, getAssistantMessageIdsForLatestUserTurn, getDerivedSubagentSessions, getEventBufferSessionId, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, getLatestTurnTokenUsage, getIdleTokenUsageDelta, getTokenUsageSessionIdsForIdle, isDerivedChildSession, hasAssistantMessageCompletedBefore, doesLatestUserTurnHaveNaturalCompletion, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, getAssistantMessageKind, getLatestUserMessage, isSummaryAssistantMessage, isSessionBusy, isAssistantTextReadyForQuestion, deriveLatestUnansweredQuestion, shouldBufferSessionEvent, } from './event-stream-state.js';
 const fixturesDir = path.join(import.meta.dirname, 'event-stream-fixtures');
 function loadFixture(filename) {
     const content = fs.readFileSync(path.join(fixturesDir, filename), 'utf8');
@@ -262,6 +262,171 @@ describe('session-user-interruption', () => {
         expect(getCurrentTurnStartTime({ events, sessionId })).toBe(1772636335777);
     });
 });
+describe('compaction summary during an active user turn', () => {
+    const sessionId = 'ses_compaction';
+    const userMessageId = 'msg_user_compaction';
+    const replyMessageId = 'msg_reply_compaction';
+    const summaryMessageId = 'msg_summary_compaction';
+    function assistantEvent({ messageId, created, completed, summary, }) {
+        return eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: messageId,
+                    sessionID: sessionId,
+                    role: 'assistant',
+                    parentID: userMessageId,
+                    time: { created, completed },
+                    modelID: summary ? 'compaction-model' : 'reply-model',
+                    providerID: 'test-provider',
+                    mode: summary ? 'compaction' : 'build',
+                    agent: summary ? 'compaction' : 'build',
+                    path: { cwd: '/test', root: '/test' },
+                    cost: summary ? 2 : 1,
+                    tokens: {
+                        input: summary ? 20 : 10,
+                        output: 1,
+                        reasoning: 0,
+                        cache: { read: 0, write: 0 },
+                    },
+                    finish: completed ? 'stop' : undefined,
+                    summary,
+                },
+            },
+        });
+    }
+    const activeEvents = [
+        eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: userMessageId,
+                    sessionID: sessionId,
+                    role: 'user',
+                    time: { created: 1 },
+                    agent: 'build',
+                    model: { providerID: 'test-provider', modelID: 'reply-model' },
+                },
+            },
+        }),
+        assistantEvent({ messageId: replyMessageId, created: 2 }),
+        assistantEvent({
+            messageId: summaryMessageId,
+            created: 3,
+            completed: 4,
+            summary: true,
+        }),
+    ];
+    test('compaction completion does not replace or complete the user-facing reply', () => {
+        expect(getAssistantMessageIdsForLatestUserTurn({
+            events: activeEvents,
+            sessionId,
+        })).toEqual(new Set([replyMessageId]));
+        expect(getLatestAssistantMessageIdForLatestUserTurn({
+            events: activeEvents,
+            sessionId,
+        })).toBe(replyMessageId);
+        expect(isAssistantMessageInLatestUserTurn({
+            events: activeEvents,
+            sessionId,
+            messageId: summaryMessageId,
+        })).toBe(false);
+        expect(doesLatestUserTurnHaveNaturalCompletion({
+            events: activeEvents,
+            sessionId,
+        })).toBe(false);
+    });
+    test('summary identity is derivable while its billed usage remains counted', () => {
+        expect(getAssistantMessageKind({
+            events: activeEvents.slice(0, 2),
+            sessionId,
+            messageId: summaryMessageId,
+        })).toBe('unknown');
+        expect(getAssistantMessageKind({
+            events: activeEvents,
+            sessionId,
+            messageId: summaryMessageId,
+        })).toBe('summary');
+        expect(getAssistantMessageKind({
+            events: activeEvents,
+            sessionId,
+            messageId: replyMessageId,
+        })).toBe('user-facing');
+        expect(isSummaryAssistantMessage({
+            events: activeEvents,
+            sessionId,
+            messageId: summaryMessageId,
+        })).toBe(true);
+        expect(isAssistantMessageNaturalCompletion({
+            message: getAssistantMessageById({
+                events: activeEvents,
+                sessionId,
+                messageId: summaryMessageId,
+            }),
+        })).toBe(false);
+        expect(getLatestRunInfo({ events: activeEvents, sessionId })).toEqual({
+            model: 'reply-model',
+            providerID: 'test-provider',
+            agent: 'build',
+            tokensUsed: 11,
+        });
+        expect(getLatestTurnTokenUsage({ events: activeEvents, sessionId })).toMatchObject({
+            total: 32,
+            cost: 3,
+            assistantMessageCount: 2,
+        });
+    });
+    test('the real continuation still completes normally after compaction', () => {
+        const completedEvents = [
+            ...activeEvents,
+            assistantEvent({ messageId: replyMessageId, created: 2, completed: 5 }),
+        ];
+        expect(doesLatestUserTurnHaveNaturalCompletion({
+            events: completedEvents,
+            sessionId,
+        })).toBe(true);
+    });
+    test('compaction user messages do not steal the latest user-facing turn', () => {
+        const compactionUserId = 'msg_compaction_user';
+        const events = [
+            ...activeEvents,
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: compactionUserId,
+                        sessionID: sessionId,
+                        role: 'user',
+                        time: { created: 6 },
+                        agent: 'build',
+                        model: { providerID: 'test-provider', modelID: 'reply-model' },
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.part.updated',
+                properties: {
+                    sessionID: sessionId,
+                    part: {
+                        id: 'prt_compaction',
+                        sessionID: sessionId,
+                        messageID: compactionUserId,
+                        type: 'compaction',
+                        auto: true,
+                    },
+                },
+            }),
+        ];
+        expect(getLatestUserMessage({ events, sessionId })?.id).toBe(userMessageId);
+        expect(getAssistantMessageIdsForLatestUserTurn({
+            events,
+            sessionId,
+        })).toEqual(new Set([replyMessageId]));
+    });
+});
 describe('session-two-completions-same-session', () => {
     const events = loadFixture('session-two-completions-same-session.jsonl');
     const sessionId = getSessionId(events);
@@ -983,7 +1148,7 @@ describe('getLatestTurnTokenUsage', () => {
             assistantMessageCount: 2,
         });
     });
-    test('returns empty when the session has no user message', () => {
+    test('sums assistant tokens when the session has no user message', () => {
         const sessionId = 'ses_no_user';
         const events = [
             assistantEvent({
@@ -1000,16 +1165,16 @@ describe('getLatestTurnTokenUsage', () => {
             }),
         ];
         expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
-            input: 0,
-            output: 0,
+            input: 100,
+            output: 10,
             reasoning: 0,
             cacheRead: 0,
             cacheWrite: 0,
-            total: 0,
+            total: 110,
             cost: 0,
-            model: undefined,
-            providerID: undefined,
-            assistantMessageCount: 0,
+            model: 'gpt-5.3-codex',
+            providerID: 'openai',
+            assistantMessageCount: 1,
             userMessageId: undefined,
         });
     });
@@ -1176,4 +1341,567 @@ describe('getIdleTokenUsageDelta', () => {
             total: 20,
         });
     });
+    test('counts child session assistant tokens without a user message.updated', () => {
+        const childSessionId = 'ses_task_child';
+        const events = [
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: childSessionId,
+                    info: {
+                        id: 'msg_child_asst_1',
+                        sessionID: childSessionId,
+                        role: 'assistant',
+                        time: { created: 2, completed: 3 },
+                        parentID: 'msg_child_user_missing',
+                        modelID: 'gpt-5.3-codex',
+                        providerID: 'openai',
+                        mode: 'general',
+                        agent: 'general',
+                        path: { cwd: '/test', root: '/test' },
+                        cost: 0.02,
+                        tokens: {
+                            total: 40,
+                            input: 30,
+                            output: 10,
+                            reasoning: 4,
+                            cache: { read: 0, write: 0 },
+                        },
+                        finish: 'stop',
+                    },
+                },
+            }),
+            idleEvent(childSessionId),
+        ];
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId: childSessionId,
+            idleEventIndex: events.length - 1,
+        })).toMatchObject({
+            input: 30,
+            output: 10,
+            reasoning: 4,
+            total: 40,
+            cost: 0.02,
+            assistantMessageCount: 1,
+        });
+    });
+    test('falls back to session.updated Session.tokens for a child with no message.updated', () => {
+        const childSessionId = 'ses_task_child_session_tokens';
+        const events = [
+            eventEntry({
+                type: 'session.updated',
+                properties: {
+                    sessionID: childSessionId,
+                    info: {
+                        id: childSessionId,
+                        slug: 'child',
+                        projectID: 'prj_1',
+                        directory: '/test',
+                        parentID: 'ses_main',
+                        title: 'child task',
+                        version: '1',
+                        cost: 0.05,
+                        tokens: {
+                            input: 100,
+                            output: 20,
+                            reasoning: 8,
+                            cache: { read: 4, write: 1 },
+                        },
+                        time: { created: 1, updated: 2 },
+                    },
+                },
+            }),
+            idleEvent(childSessionId),
+        ];
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId: childSessionId,
+            idleEventIndex: events.length - 1,
+        })).toMatchObject({
+            input: 100,
+            output: 20,
+            reasoning: 8,
+            cacheRead: 4,
+            cacheWrite: 1,
+            total: 133,
+            cost: 0.05,
+        });
+    });
+    test('does not re-emit child tokens at parent idle after the child already idled', () => {
+        const childSessionId = 'ses_task_child_dedupe';
+        const events = [
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: childSessionId,
+                    info: {
+                        id: 'msg_child_asst_1',
+                        sessionID: childSessionId,
+                        role: 'assistant',
+                        time: { created: 2, completed: 3 },
+                        parentID: 'msg_child_user_missing',
+                        modelID: 'gpt-5.3-codex',
+                        providerID: 'openai',
+                        mode: 'general',
+                        agent: 'general',
+                        path: { cwd: '/test', root: '/test' },
+                        cost: 0,
+                        tokens: {
+                            total: 40,
+                            input: 30,
+                            output: 10,
+                            reasoning: 0,
+                            cache: { read: 0, write: 0 },
+                        },
+                        finish: 'stop',
+                    },
+                },
+            }),
+            idleEvent(childSessionId),
+            idleEvent('ses_main'),
+        ];
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId: childSessionId,
+            idleEventIndex: 1,
+        })).toMatchObject({ total: 40 });
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId: childSessionId,
+            idleEventIndex: 2,
+        })).toBeUndefined();
+    });
+});
+describe('task child session token tracking', () => {
+    function idleEvent(sessionId) {
+        return eventEntry({
+            type: 'session.idle',
+            properties: { sessionID: sessionId },
+        });
+    }
+    test('isDerivedChildSession is true from session.created parentID before task metadata', () => {
+        const mainSessionId = 'ses_main';
+        const childSessionId = 'ses_child';
+        const events = [
+            eventEntry({
+                type: 'session.created',
+                properties: {
+                    sessionID: childSessionId,
+                    info: {
+                        id: childSessionId,
+                        slug: 'child',
+                        projectID: 'prj_1',
+                        directory: '/test',
+                        parentID: mainSessionId,
+                        title: 'explore files',
+                        version: '1',
+                        time: { created: 1, updated: 1 },
+                    },
+                },
+            }),
+        ];
+        expect(isDerivedChildSession({
+            events,
+            mainSessionId,
+            candidateSessionId: childSessionId,
+        })).toBe(true);
+        expect(isDerivedChildSession({
+            events,
+            mainSessionId,
+            candidateSessionId: 'ses_unrelated',
+        })).toBe(false);
+    });
+    test('main idle also returns child session ids so their tokens can be tracked', () => {
+        const mainSessionId = 'ses_main';
+        const childSessionId = 'ses_child';
+        const events = [
+            eventEntry({
+                type: 'session.created',
+                properties: {
+                    sessionID: childSessionId,
+                    info: {
+                        id: childSessionId,
+                        slug: 'child',
+                        projectID: 'prj_1',
+                        directory: '/test',
+                        parentID: mainSessionId,
+                        title: 'child task',
+                        version: '1',
+                        time: { created: 1, updated: 1 },
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.part.updated',
+                properties: {
+                    part: {
+                        id: 'prt_task',
+                        sessionID: mainSessionId,
+                        messageID: 'msg_asst',
+                        type: 'tool',
+                        callID: 'call_task',
+                        tool: 'task',
+                        state: {
+                            status: 'running',
+                            input: { subagent_type: 'general' },
+                            metadata: { sessionId: childSessionId },
+                        },
+                    },
+                },
+            }),
+            idleEvent(mainSessionId),
+        ];
+        expect(getTokenUsageSessionIdsForIdle({
+            events,
+            mainSessionId,
+            idleSessionId: mainSessionId,
+        })).toEqual([mainSessionId, childSessionId]);
+        expect(getTokenUsageSessionIdsForIdle({
+            events,
+            mainSessionId,
+            idleSessionId: childSessionId,
+        })).toEqual([childSessionId]);
+    });
+});
+describe('question waits for preceding text-end', () => {
+    const sessionId = 'ses_question_text';
+    const messageId = 'msg_asst_question';
+    const questionId = 'que_1';
+    const textStart = eventEntry({
+        type: 'message.part.updated',
+        properties: {
+            sessionID: sessionId,
+            part: {
+                id: 'prt_text',
+                sessionID: sessionId,
+                messageID: messageId,
+                type: 'text',
+                text: '',
+                time: { start: 1 },
+            },
+        },
+    });
+    const questionAsked = eventEntry({
+        type: 'question.asked',
+        properties: {
+            id: questionId,
+            sessionID: sessionId,
+            questions: [{
+                    question: 'What next?',
+                    header: 'Next step',
+                    options: [
+                        { label: 'Commit', description: 'Commit these files' },
+                    ],
+                }],
+            tool: {
+                messageID: messageId,
+                callID: 'call_question',
+            },
+        },
+    });
+    const textEnd = eventEntry({
+        type: 'message.part.updated',
+        properties: {
+            sessionID: sessionId,
+            part: {
+                id: 'prt_text',
+                sessionID: sessionId,
+                messageID: messageId,
+                type: 'text',
+                text: 'Done callout',
+                time: { start: 1, end: 2 },
+            },
+        },
+    });
+    const questionError = eventEntry({
+        type: 'message.part.updated',
+        properties: {
+            sessionID: sessionId,
+            part: {
+                id: 'prt_question',
+                sessionID: sessionId,
+                messageID: messageId,
+                type: 'tool',
+                tool: 'question',
+                callID: 'call_question',
+                state: {
+                    status: 'error',
+                    error: 'Aborted',
+                    time: { start: 2, end: 3 },
+                },
+            },
+        },
+    });
+    test('text is not ready when question.asked arrives before time.end', () => {
+        const events = [textStart, questionAsked];
+        expect(isAssistantTextReadyForQuestion({
+            events,
+            sessionId,
+            messageId,
+        })).toBe(false);
+        expect(deriveLatestUnansweredQuestion({
+            events,
+            sessionId,
+        })).toMatchObject({
+            id: questionId,
+            tool: { messageID: messageId },
+        });
+    });
+    test('text is ready after time.end, and still unanswered', () => {
+        const events = [textStart, questionAsked, textEnd];
+        expect(isAssistantTextReadyForQuestion({
+            events,
+            sessionId,
+            messageId,
+        })).toBe(true);
+        expect(deriveLatestUnansweredQuestion({
+            events,
+            sessionId,
+        })?.id).toBe(questionId);
+    });
+    test('no text part means the question is ready immediately', () => {
+        const events = [questionAsked];
+        expect(isAssistantTextReadyForQuestion({
+            events,
+            sessionId,
+            messageId,
+        })).toBe(true);
+    });
+    test('aborted question is not unanswered', () => {
+        const events = [textStart, questionAsked, textEnd, questionError];
+        expect(deriveLatestUnansweredQuestion({
+            events,
+            sessionId,
+        })).toBeUndefined();
+    });
+    test('question from an older user turn is not unanswered', () => {
+        const firstUser = eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: 'msg_user_first',
+                    sessionID: sessionId,
+                    role: 'user',
+                    time: { created: 1 },
+                    agent: 'build',
+                    model: {
+                        providerID: 'deterministic-provider',
+                        modelID: 'deterministic-v2',
+                    },
+                },
+            },
+        });
+        const questionAssistant = eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: messageId,
+                    sessionID: sessionId,
+                    role: 'assistant',
+                    time: { created: 2 },
+                    parentID: 'msg_user_first',
+                    modelID: 'deterministic-v2',
+                    providerID: 'deterministic-provider',
+                    mode: 'build',
+                    agent: 'build',
+                    path: { cwd: '/test', root: '/test' },
+                    cost: 0,
+                    tokens: {
+                        input: 1,
+                        output: 1,
+                        reasoning: 0,
+                        cache: { read: 0, write: 0 },
+                    },
+                },
+            },
+        });
+        const nextUser = eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: 'msg_user_commit',
+                    sessionID: sessionId,
+                    role: 'user',
+                    time: { created: 3 },
+                    agent: 'build',
+                    model: {
+                        providerID: 'deterministic-provider',
+                        modelID: 'deterministic-v2',
+                    },
+                },
+            },
+        });
+        const events = [
+            firstUser,
+            questionAssistant,
+            textStart,
+            questionAsked,
+            textEnd,
+            nextUser,
+        ];
+        expect(deriveLatestUnansweredQuestion({
+            events,
+            sessionId,
+        })).toBeUndefined();
+    });
+});
+describe('shouldBufferSessionEvent', () => {
+    const mainSessionId = 'ses_parent';
+    const childSessionId = 'ses_child';
+    const btwSessionId = 'ses_btw_fork';
+    test('keeps the thread session and drops unrelated /btw fork events', () => {
+        const parentBusy = eventEntry({
+            type: 'session.status',
+            properties: {
+                sessionID: mainSessionId,
+                status: { type: 'busy' },
+            },
+        }).event;
+        const btwClone = eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: btwSessionId,
+                info: {
+                    id: 'msg_cloned',
+                    sessionID: btwSessionId,
+                    role: 'user',
+                    time: { created: 1 },
+                    agent: 'build',
+                    model: { providerID: 'test', modelID: 'test' },
+                },
+            },
+        }).event;
+        expect(shouldBufferSessionEvent({
+            event: parentBusy,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(true);
+        expect(shouldBufferSessionEvent({
+            event: btwClone,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(false);
+    });
+    test('keeps the first child session.created so later child events can be recognized', () => {
+        const childCreated = eventEntry({
+            type: 'session.created',
+            properties: {
+                info: {
+                    id: childSessionId,
+                    parentID: mainSessionId,
+                    title: 'task',
+                    version: '1',
+                    projectID: 'proj',
+                    directory: '/test',
+                    time: { created: 1, updated: 1 },
+                },
+            },
+        }).event;
+        expect(shouldBufferSessionEvent({
+            event: childCreated,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(true);
+    });
+    test('keeps known child session events and global toasts', () => {
+        const childBusy = eventEntry({
+            type: 'session.status',
+            properties: {
+                sessionID: childSessionId,
+                status: { type: 'busy' },
+            },
+        }).event;
+        const toast = eventEntry({
+            type: 'tui.toast.show',
+            properties: {
+                title: 'ok',
+                message: 'done',
+                variant: 'info',
+            },
+        }).event;
+        const diff = eventEntry({
+            type: 'session.diff',
+            properties: {
+                sessionID: mainSessionId,
+                diff: [],
+            },
+        }).event;
+        expect(shouldBufferSessionEvent({
+            event: childBusy,
+            mainSessionId,
+            isKnownChildSession: (sessionId) => sessionId === childSessionId,
+        })).toBe(true);
+        expect(shouldBufferSessionEvent({
+            event: toast,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(true);
+        expect(shouldBufferSessionEvent({
+            event: diff,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(false);
+    });
+    test('drops unrelated session.next text deltas that lack a typed session helper', () => {
+        const btwDelta = eventEntry({
+            type: 'session.next.text.delta',
+            properties: {
+                timestamp: 1,
+                sessionID: btwSessionId,
+                assistantMessageID: 'msg_btw',
+                textID: 'txt_btw',
+                delta: 'x',
+            },
+        }).event;
+        const parentDelta = eventEntry({
+            type: 'session.next.text.delta',
+            properties: {
+                timestamp: 1,
+                sessionID: mainSessionId,
+                assistantMessageID: 'msg_parent',
+                textID: 'txt_parent',
+                delta: 'x',
+            },
+        }).event;
+        expect(getEventBufferSessionId(btwDelta)).toBe(btwSessionId);
+        expect(shouldBufferSessionEvent({
+            event: btwDelta,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(false);
+        expect(shouldBufferSessionEvent({
+            event: parentDelta,
+            mainSessionId,
+            isKnownChildSession: () => false,
+        })).toBe(false);
+    });
+    test('drops scoped events until the thread session id is bound', () => {
+        const parentBusy = eventEntry({
+            type: 'session.status',
+            properties: {
+                sessionID: mainSessionId,
+                status: { type: 'busy' },
+            },
+        }).event;
+        const toast = eventEntry({
+            type: 'tui.toast.show',
+            properties: {
+                title: 'ok',
+                message: 'done',
+                variant: 'info',
+            },
+        }).event;
+        expect(shouldBufferSessionEvent({
+            event: parentBusy,
+            isKnownChildSession: () => false,
+        })).toBe(false);
+        expect(shouldBufferSessionEvent({
+            event: toast,
+            isKnownChildSession: () => false,
+        })).toBe(true);
+    });
 });