kimaki 0.28.0 → 0.29.0

package/dist/message-formatting.test.js

@@ -42,6 +42,28 @@ describe('formatPart', () => {
       Done."
     `);
     });
+    test('synthetic user context stays hidden', () => {
+        const part = {
+            id: 'prt_branch',
+            type: 'text',
+            sessionID: 'ses_test',
+            messageID: 'msg_user',
+            text: '\n[current git branch is main]\n',
+            synthetic: true,
+        };
+        expect(formatPart(part)).toBe('');
+    });
+    test('ignored plugin notices stay visible', () => {
+        const part = {
+            id: 'prt_notice',
+            type: 'text',
+            sessionID: 'ses_test',
+            messageID: 'msg_notice',
+            text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+            ignored: true,
+        };
+        expect(formatPart(part)).toBe('Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.');
+    });
 });
 describe('asDiscordQuote', () => {
     test('prefixes every line', () => {
@@ -144,7 +166,7 @@ describe('planAssistantTurnFlush', () => {
       }
     `);
     });
-    test('progress holds unfinished last text and following tools', () => {
+    test('progress sends tools immediately while unfinished text is held', () => {
         expect(plan([text('t1', 'status', false), tool('tool1')], 'progress')).toMatchInlineSnapshot(`
       {
         "hold": [
@@ -152,15 +174,51 @@ describe('planAssistantTurnFlush', () => {
             "id": "t1",
             "quoteText": false,
           },
+        ],
+        "send": [
           {
             "id": "tool1",
             "quoteText": false,
           },
         ],
+      }
+    `);
+    });
+    test('progress holds unfinished text only when nothing else is ready', () => {
+        expect(plan([text('t1', 'status', false)], 'progress')).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t1",
+            "quoteText": false,
+          },
+        ],
         "send": [],
       }
     `);
     });
+    test('progress sends completed text and later tools while later text is still open', () => {
+        expect(plan([text('t1', 'first'), text('t2', 'second', false), tool('tool1')], 'progress')).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t2",
+            "quoteText": false,
+          },
+        ],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `);
+    });
     test('progress holds unfinished last text until it ends', () => {
         expect(plan([text('t1', 'first'), text('t2', 'second', false)], 'progress')).toMatchInlineSnapshot(`
       {
@@ -284,6 +342,17 @@ describe('planAssistantTurnFlush', () => {
     test('progress still quotes two-line earlier text', () => {
         expect(plan([text('t1', 'line one\nline two'), tool('tool1'), text('t2', 'answer')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({ id: 't1', quoteText: true });
     });
+    test('progress keeps sleep-tool quote context after that tool is already sent', () => {
+        const parts = [text('t1', 'wait'), tool('sleep1', 'kimaki_sleep')];
+        expect(plan(parts, 'progress').send.find((entry) => entry.id === 't1')).toEqual({
+            id: 't1',
+            quoteText: false,
+        });
+        expect(plan([text('t1', 'wait')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({
+            id: 't1',
+            quoteText: true,
+        });
+    });
     test('progress does not quote earlier text before an interactive tool', () => {
         expect(plan([text('t1', 'ask'), tool('question1', 'question'), text('t2', 'later')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({ id: 't1', quoteText: false });
         expect(plan([text('t1', 'wait'), tool('sleep1', 'kimaki_sleep'), text('t2', 'later')], 'progress').send.find((entry) => entry.id === 't1')).toEqual({ id: 't1', quoteText: false });
@@ -318,15 +387,35 @@ describe('sessionPartContent', () => {
     });
 });
 describe('collectSessionChunks', () => {
-    function textPart({ id, text, messageID, }) {
+    function textPart({ id, text, messageID, synthetic, }) {
         return {
             id,
             type: 'text',
             sessionID: 'ses_test',
             messageID,
             text,
+            synthetic,
         };
     }
+    test('skips synthetic text parts', () => {
+        const { chunks } = collectSessionChunks({
+            messages: [
+                {
+                    info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user' },
+                    parts: [
+                        textPart({
+                            id: 'branch',
+                            text: '\n[current git branch is main]\n',
+                            messageID: 'msg_1',
+                            synthetic: true,
+                        }),
+                        textPart({ id: 't1', text: 'working', messageID: 'msg_1' }),
+                    ],
+                },
+            ],
+        });
+        expect(chunks.map((chunk) => chunk.content)).toEqual(['> working']);
+    });
     test('quotes short text throughout a turn', () => {
         const { chunks } = collectSessionChunks({
             messages: [

package/dist/schema.js

@@ -32,6 +32,15 @@ export const thread_sessions = sqliteCore.sqliteTable('thread_sessions', {
     // Without it the reverse lookup is arbitrary and tools can target a dead thread.
     updated_at: datetime('updated_at').default(orm.sql `CURRENT_TIMESTAMP`).$onUpdate(() => new Date()),
 });
+export const thread_queue_items = sqliteCore.sqliteTable('thread_queue_items', {
+    id: sqliteCore.integer('id', { mode: 'number' }).primaryKey({ autoIncrement: true }).notNull(),
+    queue_id: sqliteCore.text('queue_id').notNull().unique(),
+    thread_id: sqliteCore.text('thread_id').notNull(),
+    payload_json: sqliteCore.text('payload_json').notNull(),
+    created_at: datetime('created_at').default(orm.sql `CURRENT_TIMESTAMP`),
+}, (table) => [
+    sqliteCore.index('thread_queue_items_thread_id_id_idx').on(table.thread_id, table.id),
+]);
 export const session_events = sqliteCore.sqliteTable('session_events', {
     id: sqliteCore.integer('id', { mode: 'number' }).primaryKey({ autoIncrement: true }).notNull(),
     session_id: sqliteCore.text('session_id').notNull(),
@@ -68,6 +77,14 @@ export const channel_directories = sqliteCore.sqliteTable('channel_directories',
     guild_id: sqliteCore.text('guild_id'),
     created_at: datetime('created_at').default(orm.sql `CURRENT_TIMESTAMP`),
 });
+// One Discord category pair per guild for this machine. Look up by snowflake
+// id, never by name, so a rename still routes new channels here.
+export const guild_categories = sqliteCore.sqliteTable('guild_categories', {
+    guild_id: sqliteCore.text('guild_id').primaryKey().notNull(),
+    category_id: sqliteCore.text('category_id'),
+    audio_category_id: sqliteCore.text('audio_category_id'),
+    created_at: datetime('created_at').default(orm.sql `CURRENT_TIMESTAMP`),
+});
 export const bot_api_keys = sqliteCore.sqliteTable('bot_api_keys', {
     app_id: sqliteCore.text('app_id').primaryKey().notNull().references(() => bot_tokens.app_id, { onUpdate: 'cascade' }),
     gemini_api_key: sqliteCore.text('gemini_api_key'),
@@ -246,6 +263,7 @@ export const ipc_requests = sqliteCore.sqliteTable('ipc_requests', {
 ]);
 export const relations = defineRelations({
     thread_sessions,
+    thread_queue_items,
     session_events,
     part_messages,
     bot_tokens,
@@ -253,6 +271,7 @@ export const relations = defineRelations({
     thread_worktrees,
     thread_workspaces,
     channel_directories,
+    guild_categories,
     channel_models,
     session_models,
     channel_agents,
@@ -276,6 +295,7 @@ export const relations = defineRelations({
         thread_workspace: r.one.thread_workspaces({ from: r.thread_sessions.thread_id, to: r.thread_workspaces.thread_id }),
         ipc_requests: r.many.ipc_requests(),
     },
+    thread_queue_items: {},
     session_events: {
         thread: r.one.thread_sessions({ from: r.session_events.thread_id, to: r.thread_sessions.thread_id }),
     },
@@ -296,6 +316,7 @@ export const relations = defineRelations({
     thread_workspaces: {
         thread: r.one.thread_sessions({ from: r.thread_workspaces.thread_id, to: r.thread_sessions.thread_id }),
     },
+    guild_categories: {},
     channel_directories: {
         channel_model: r.one.channel_models({ from: r.channel_directories.channel_id, to: r.channel_models.channel_id }),
         channel_agent: r.one.channel_agents({ from: r.channel_directories.channel_id, to: r.channel_agents.channel_id }),

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

@@ -17,6 +17,9 @@ function isCompactionContinuePart(part) {
 }
 function isInternalOpenCodeUserMessageId({ events, sessionId, messageId, upToIndex, }) {
     const end = upToIndex ?? events.length - 1;
+    let sawPart = false;
+    let hasUserTurnInput = false;
+    let hasIgnoredNotice = false;
     for (let i = 0; i <= end; i++) {
         const event = events[i]?.event;
         if (event?.type !== 'message.part.updated') {
@@ -26,14 +29,29 @@ function isInternalOpenCodeUserMessageId({ events, sessionId, messageId, upToInd
         if (part.sessionID !== sessionId || part.messageID !== messageId) {
             continue;
         }
+        sawPart = true;
         if (part.type === 'compaction') {
             return true;
         }
         if (isCompactionContinuePart(part)) {
             return true;
         }
+        if (part.type === 'text') {
+            if (part.synthetic === true) {
+                continue;
+            }
+            if (part.ignored === true) {
+                hasIgnoredNotice = true;
+                continue;
+            }
+            if (part.text?.trim()) {
+                hasUserTurnInput = true;
+            }
+            continue;
+        }
+        hasUserTurnInput = true;
     }
-    return false;
+    return sawPart && hasIgnoredNotice && !hasUserTurnInput;
 }
 function isUserFacingAssistantMessage(message) {
     return message.summary !== true;
@@ -581,6 +599,36 @@ export function getAssistantMessageIdsForLatestUserTurn({ events, sessionId, upT
         return new Set();
     }
     const end = upToIndex === undefined ? events.length : upToIndex + 1;
+    const firstUserMessageIndexes = new Map();
+    for (let i = 0; i < end; i++) {
+        const event = events[i]?.event;
+        if (event?.type !== 'message.updated') {
+            continue;
+        }
+        const message = event.properties.info;
+        if (message.sessionID === sessionId
+            && message.role === 'user'
+            && !firstUserMessageIndexes.has(message.id)) {
+            firstUserMessageIndexes.set(message.id, i);
+        }
+    }
+    const latestUserMessageIndex = firstUserMessageIndexes.get(latestUserMessage.id);
+    const turnParentMessageIds = new Set([latestUserMessage.id]);
+    if (latestUserMessageIndex !== undefined) {
+        for (const [messageId, messageIndex] of firstUserMessageIndexes) {
+            if (messageIndex < latestUserMessageIndex) {
+                continue;
+            }
+            if (isInternalOpenCodeUserMessageId({
+                events,
+                sessionId,
+                messageId,
+                upToIndex,
+            })) {
+                turnParentMessageIds.add(messageId);
+            }
+        }
+    }
     const assistantMessageIds = new Set();
     for (let i = 0; i < end; i++) {
         const entry = events[i];
@@ -598,7 +646,7 @@ export function getAssistantMessageIdsForLatestUserTurn({ events, sessionId, upT
         if (!isUserFacingAssistantMessage(msg)) {
             continue;
         }
-        if (msg.parentID === latestUserMessage.id) {
+        if (turnParentMessageIds.has(msg.parentID)) {
             assistantMessageIds.add(msg.id);
         }
     }
@@ -625,12 +673,12 @@ export function didLatestUserTurnUseSleepTool({ events, sessionId, upToIndex, })
     return false;
 }
 export function getLatestAssistantMessageIdForLatestUserTurn({ events, sessionId, upToIndex, }) {
-    const latestUserMessage = getLatestUserMessage({
+    const assistantMessageIds = getAssistantMessageIdsForLatestUserTurn({
         events,
         sessionId,
         upToIndex,
     });
-    if (!latestUserMessage) {
+    if (assistantMessageIds.size === 0) {
         return undefined;
     }
     const end = upToIndex ?? events.length - 1;
@@ -651,7 +699,7 @@ export function getLatestAssistantMessageIdForLatestUserTurn({ events, sessionId
         if (!isUserFacingAssistantMessage(info)) {
             continue;
         }
-        if (info.parentID !== latestUserMessage.id) {
+        if (!assistantMessageIds.has(info.id)) {
             continue;
         }
         if (!latestAssistantMessage) {

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

@@ -476,6 +476,229 @@ describe('session-concurrent-messages-serialized', () => {
         expect(message.id).toBe(latestAssistantMessageId);
     });
 });
+describe('ignored plugin notices do not steal the current Discord turn', () => {
+    const sessionId = 'ses_notice';
+    const userMessageId = 'msg_user';
+    const replyMessageId = 'msg_asst';
+    const noticeMessageId = 'msg_notice';
+    const replyAfterNoticeMessageId = 'msg_asst_after_notice';
+    const events = [
+        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' },
+                },
+            },
+        }),
+        eventEntry({
+            type: 'message.part.updated',
+            properties: {
+                sessionID: sessionId,
+                part: {
+                    id: 'prt_prompt',
+                    sessionID: sessionId,
+                    messageID: userMessageId,
+                    type: 'text',
+                    text: 'see how we display in discord tool calls',
+                },
+            },
+        }),
+        eventEntry({
+            type: 'message.part.updated',
+            properties: {
+                sessionID: sessionId,
+                part: {
+                    id: 'prt_branch',
+                    sessionID: sessionId,
+                    messageID: userMessageId,
+                    type: 'text',
+                    text: '\n[current git branch is main]\n',
+                    synthetic: true,
+                },
+            },
+        }),
+        eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: replyMessageId,
+                    sessionID: sessionId,
+                    role: 'assistant',
+                    parentID: userMessageId,
+                    time: { created: 2 },
+                    modelID: 'reply-model',
+                    providerID: 'test-provider',
+                    mode: 'build',
+                    agent: 'build',
+                    path: { cwd: '/test', root: '/test' },
+                    cost: 1,
+                    tokens: {
+                        input: 10,
+                        output: 1,
+                        reasoning: 0,
+                        cache: { read: 0, write: 0 },
+                    },
+                },
+            },
+        }),
+        eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: noticeMessageId,
+                    sessionID: sessionId,
+                    role: 'user',
+                    time: { created: 3 },
+                    agent: 'build',
+                    model: { providerID: 'subrouter', modelID: 'build' },
+                },
+            },
+        }),
+        eventEntry({
+            type: 'message.part.updated',
+            properties: {
+                sessionID: sessionId,
+                part: {
+                    id: 'prt_notice',
+                    sessionID: sessionId,
+                    messageID: noticeMessageId,
+                    type: 'text',
+                    text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+                    ignored: true,
+                },
+            },
+        }),
+        eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: replyAfterNoticeMessageId,
+                    sessionID: sessionId,
+                    role: 'assistant',
+                    parentID: noticeMessageId,
+                    time: { created: 4, completed: 5 },
+                    modelID: 'build',
+                    providerID: 'subrouter',
+                    mode: 'build',
+                    agent: 'build',
+                    path: { cwd: '/test', root: '/test' },
+                    cost: 1,
+                    tokens: {
+                        input: 10,
+                        output: 1,
+                        reasoning: 0,
+                        cache: { read: 0, write: 0 },
+                    },
+                    finish: 'stop',
+                },
+            },
+        }),
+    ];
+    test('keeps the real user prompt as the latest turn', () => {
+        expect(getLatestUserMessage({ events, sessionId })?.id).toBe(userMessageId);
+        expect(getAssistantMessageIdsForLatestUserTurn({
+            events,
+            sessionId,
+        })).toEqual(new Set([replyMessageId, replyAfterNoticeMessageId]));
+        expect(getLatestAssistantMessageIdForLatestUserTurn({
+            events,
+            sessionId,
+        })).toBe(replyAfterNoticeMessageId);
+        expect(doesLatestUserTurnHaveNaturalCompletion({
+            events,
+            sessionId,
+        })).toBe(true);
+    });
+    test('keeps a file prompt with an ignored notice as the latest turn', () => {
+        const fileUserId = 'msg_file_user';
+        const fileAssistantId = 'msg_file_asst';
+        const fileEvents = [
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: fileUserId,
+                        sessionID: sessionId,
+                        role: 'user',
+                        time: { created: 4 },
+                        agent: 'build',
+                        model: { providerID: 'test-provider', modelID: 'reply-model' },
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.part.updated',
+                properties: {
+                    sessionID: sessionId,
+                    part: {
+                        id: 'prt_file',
+                        sessionID: sessionId,
+                        messageID: fileUserId,
+                        type: 'file',
+                        mime: 'image/png',
+                        filename: 'shot.png',
+                        url: 'https://example.com/shot.png',
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.part.updated',
+                properties: {
+                    sessionID: sessionId,
+                    part: {
+                        id: 'prt_file_notice',
+                        sessionID: sessionId,
+                        messageID: fileUserId,
+                        type: 'text',
+                        text: 'Subrouter: Using openai/gpt-5.6-sol because xai/grok-4.6 is rate limited.',
+                        ignored: true,
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: fileAssistantId,
+                        sessionID: sessionId,
+                        role: 'assistant',
+                        parentID: fileUserId,
+                        time: { created: 5 },
+                        modelID: 'reply-model',
+                        providerID: 'test-provider',
+                        mode: 'build',
+                        agent: 'build',
+                        path: { cwd: '/test', root: '/test' },
+                        cost: 1,
+                        tokens: {
+                            input: 10,
+                            output: 1,
+                            reasoning: 0,
+                            cache: { read: 0, write: 0 },
+                        },
+                    },
+                },
+            }),
+        ];
+        expect(getLatestUserMessage({ events: fileEvents, sessionId })?.id).toBe(fileUserId);
+        expect(getAssistantMessageIdsForLatestUserTurn({
+            events: fileEvents,
+            sessionId,
+        })).toEqual(new Set([fileAssistantId]));
+    });
+});
 describe('session-tool-call-noisy-stream', () => {
     const events = loadFixture('session-tool-call-noisy-stream.jsonl');
     const sessionId = getSessionId(events);

package/dist/session-handler/thread-runtime-state.js

@@ -94,6 +94,10 @@ export function enqueueItem(threadId, item) {
         queueItems: [...t.queueItems, item],
     }));
 }
+export function replaceQueueItems(threadId, items) {
+    ensureThread(threadId);
+    updateThread(threadId, (t) => ({ ...t, queueItems: items }));
+}
 // Atomic dequeue: read + write in one setState call to prevent
 // a concurrent enqueue between read and write from losing items.
 export function dequeueItem(threadId) {