kimaki 0.4.82 → 0.4.84

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

@@ -99,6 +99,7 @@ export function hasAssistantMessageCompletedBefore({ events, sessionId, messageI
 }
 export function getLatestUserMessage({ events, sessionId, upToIndex, }) {
     const end = upToIndex ?? events.length - 1;
+    let latestUserMessage;
     for (let i = end; i >= 0; i--) {
         const entry = events[i];
         if (!entry) {
@@ -112,9 +113,15 @@ export function getLatestUserMessage({ events, sessionId, upToIndex, }) {
         if (info.sessionID !== sessionId || info.role !== 'user') {
             continue;
         }
-        return info;
+        if (!latestUserMessage) {
+            latestUserMessage = info;
+            continue;
+        }
+        if (info.time.created > latestUserMessage.time.created) {
+            latestUserMessage = info;
+        }
     }
-    return undefined;
+    return latestUserMessage;
 }
 export function getCurrentTurnStartTime({ events, sessionId, upToIndex, }) {
     const latestUserMessage = getLatestUserMessage({
@@ -202,6 +209,7 @@ export function getLatestAssistantMessageIdForLatestUserTurn({ events, sessionId
         return undefined;
     }
     const end = upToIndex ?? events.length - 1;
+    let latestAssistantMessage;
     for (let i = end; i >= 0; i--) {
         const entry = events[i];
         if (!entry) {
@@ -215,11 +223,74 @@ export function getLatestAssistantMessageIdForLatestUserTurn({ events, sessionId
         if (info.sessionID !== sessionId || info.role !== 'assistant') {
             continue;
         }
-        if (info.parentID === latestUserMessage.id) {
-            return info.id;
+        if (info.parentID !== latestUserMessage.id) {
+            continue;
+        }
+        if (!latestAssistantMessage) {
+            latestAssistantMessage = info;
+            continue;
+        }
+        if (info.time.created > latestAssistantMessage.time.created) {
+            latestAssistantMessage = info;
         }
     }
-    return undefined;
+    return latestAssistantMessage?.id;
+}
+function hasRenderablePartSummary(message) {
+    if (!('partsSummary' in message) || !Array.isArray(message.partsSummary)) {
+        return false;
+    }
+    return message.partsSummary.some((part) => {
+        return part.type === 'text' || part.type === 'tool';
+    });
+}
+function hasAssistantPartEvidence({ events, sessionId, messageId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    for (let i = end; i >= 0; i--) {
+        const entry = events[i];
+        if (!entry) {
+            continue;
+        }
+        const event = entry.event;
+        if (event.type === 'message.updated') {
+            const info = event.properties.info;
+            if (info.sessionID !== sessionId || info.role !== 'assistant' || info.id !== messageId) {
+                continue;
+            }
+            if (hasRenderablePartSummary(info)) {
+                return true;
+            }
+            continue;
+        }
+        if (event.type !== 'message.part.updated') {
+            continue;
+        }
+        const { part } = event.properties;
+        if (part.messageID !== messageId) {
+            continue;
+        }
+        if (part.type === 'text' || part.type === 'tool') {
+            return true;
+        }
+    }
+    return false;
+}
+function hasAssistantStepFinished({ events, messageId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    for (let i = end; i >= 0; i--) {
+        const entry = events[i];
+        if (!entry || entry.event.type !== 'message.part.updated') {
+            continue;
+        }
+        const { part } = entry.event.properties;
+        if (part.messageID !== messageId) {
+            continue;
+        }
+        if (part.type === 'step-finish') {
+            return true;
+        }
+    }
+    return false;
 }
 export function doesLatestUserTurnHaveNaturalCompletion({ events, sessionId, upToIndex, }) {
     const latestAssistantMessageId = getLatestAssistantMessageIdForLatestUserTurn({
@@ -231,6 +302,7 @@ export function doesLatestUserTurnHaveNaturalCompletion({ events, sessionId, upT
         return false;
     }
     const end = upToIndex ?? events.length - 1;
+    let latestAssistantMessage;
     for (let i = end; i >= 0; i--) {
         const entry = events[i];
         if (!entry) {
@@ -247,9 +319,31 @@ export function doesLatestUserTurnHaveNaturalCompletion({ events, sessionId, upT
         if (info.id !== latestAssistantMessageId) {
             continue;
         }
-        return isAssistantMessageNaturalCompletion({ message: info });
+        latestAssistantMessage = info;
+        if (isAssistantMessageNaturalCompletion({ message: info })) {
+            return true;
+        }
+        break;
     }
-    return false;
+    if (!latestAssistantMessage) {
+        return false;
+    }
+    if (latestAssistantMessage.error) {
+        return false;
+    }
+    if (latestAssistantMessage.finish === 'tool-calls') {
+        return false;
+    }
+    return hasAssistantStepFinished({
+        events,
+        messageId: latestAssistantMessageId,
+        upToIndex,
+    }) && hasAssistantPartEvidence({
+        events,
+        sessionId,
+        messageId: latestAssistantMessageId,
+        upToIndex,
+    });
 }
 export function isAssistantMessageInLatestUserTurn({ events, sessionId, messageId, upToIndex, }) {
     const assistantMessageIds = getAssistantMessageIdsForLatestUserTurn({

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 { getOpencodeEventSessionId, } from './opencode-session-event-log.js';
-import { getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, isSessionBusy, } from './event-stream-state.js';
+import { getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, hasAssistantMessageCompletedBefore, doesLatestUserTurnHaveNaturalCompletion, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, isSessionBusy, } 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');
@@ -187,7 +187,11 @@ describe('session-concurrent-messages-serialized', () => {
         events,
         sessionId,
     });
-    test('fixture ends idle and latest assistant completed naturally', () => {
+    test('fixture latest turn is still incomplete even though an older turn completed', () => {
+        expect(doesLatestUserTurnHaveNaturalCompletion({
+            events,
+            sessionId,
+        })).toBe(false);
         if (!latestAssistantMessageId) {
             throw new Error('Expected latest assistant message');
         }
@@ -196,7 +200,7 @@ describe('session-concurrent-messages-serialized', () => {
             sessionId,
             messageId: latestAssistantMessageId,
         });
-        expect(isAssistantMessageNaturalCompletion({ message })).toBe(true);
+        expect(message.id).toBe(latestAssistantMessageId);
     });
 });
 describe('session-tool-call-noisy-stream', () => {

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

@@ -194,7 +194,7 @@ function getTokenTotal(tokens) {
         tokens.cache.write);
 }
 /** Check if a tool part is "essential" (shown in text-and-essential-tools mode). */
-function isEssentialToolName(toolName) {
+export function isEssentialToolName(toolName) {
     const essentialTools = [
         'edit',
         'write',
@@ -213,7 +213,7 @@ function isEssentialToolName(toolName) {
         return toolName === name || toolName.endsWith(`_${name}`);
     });
 }
-function isEssentialToolPart(part) {
+export function isEssentialToolPart(part) {
     if (part.type !== 'tool') {
         return false;
     }
@@ -630,10 +630,26 @@ export class ThreadSessionRuntime {
             // with every tool call and was the primary OOM vector — 1000 buffer entries
             // each carrying the full cumulative parts array reached 4GB+.
             const info = compacted.properties.info;
+            const partsSummary = Array.isArray(info.parts)
+                ? info.parts.flatMap((part) => {
+                    if (!part || typeof part !== 'object') {
+                        return [];
+                    }
+                    const candidate = part;
+                    if (typeof candidate.id !== 'string'
+                        || typeof candidate.type !== 'string') {
+                        return [];
+                    }
+                    return [{ id: candidate.id, type: candidate.type }];
+                })
+                : [];
             delete info.system;
             delete info.summary;
             delete info.tools;
             delete info.parts;
+            if (partsSummary.length > 0) {
+                info.partsSummary = partsSummary;
+            }
             return this.finalizeCompactedEventForEventBuffer(compacted);
         }
         if (compacted.type !== 'message.part.updated') {
@@ -1442,6 +1458,7 @@ export class ThreadSessionRuntime {
                             sessionId: request.sessionId,
                             directory: request.directory,
                             buttons: request.buttons,
+                            silent: this.getQueueLength() > 0,
                         });
                     });
                     if (showResult instanceof Error) {
@@ -1775,6 +1792,7 @@ export class ThreadSessionRuntime {
                     directory: this.projectDirectory,
                     requestId: questionRequest.id,
                     input: { questions: questionRequest.questions },
+                    silent: this.getQueueLength() > 0,
                 });
             },
         });
@@ -1787,6 +1805,49 @@ export class ThreadSessionRuntime {
             return;
         }
         this.onInteractiveUiStateChanged();
+        // When a question is answered and the local queue has items, the model may
+        // continue the same run without ever reaching the local-queue idle gate.
+        // Hand the queued items to OpenCode's own prompt queue immediately instead
+        // of waiting for tryDrainQueue() to see an idle session.
+        if (this.getQueueLength() > 0 && !this.questionReplyQueueHandoffPromise) {
+            logger.log(`[QUESTION REPLIED] Queue has ${this.getQueueLength()} items, handing off to opencode queue`);
+            this.questionReplyQueueHandoffPromise = this.handoffQueuedItemsAfterQuestionReply({
+                sessionId,
+            }).catch((error) => {
+                logger.error('[QUESTION REPLIED] Failed to hand off queued messages:', error);
+                if (error instanceof Error) {
+                    void notifyError(error, 'Failed to hand off queued messages after question reply');
+                }
+            }).finally(() => {
+                this.questionReplyQueueHandoffPromise = null;
+            });
+        }
+    }
+    // Detached helper promise for the "question answered while local queue has
+    // items" flow. Prevents starting two overlapping local->opencode queue
+    // handoff sequences when multiple question replies land close together.
+    questionReplyQueueHandoffPromise = null;
+    async handoffQueuedItemsAfterQuestionReply({ sessionId, }) {
+        if (this.listenerAborted) {
+            return;
+        }
+        if (this.state?.sessionId !== sessionId) {
+            logger.log(`[QUESTION REPLIED] Session changed before queue handoff for thread ${this.threadId}`);
+            return;
+        }
+        while (this.state?.sessionId === sessionId) {
+            const next = threadState.dequeueItem(this.threadId);
+            if (!next) {
+                return;
+            }
+            const displayText = next.command
+                ? `/${next.command.name}`
+                : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
+            if (displayText.trim()) {
+                await sendThreadMessage(this.thread, `» **${next.username}:** ${displayText}`);
+            }
+            await this.submitViaOpencodeQueue(next);
+        }
     }
     async handleSessionStatus(properties) {
         const sessionId = this.state?.sessionId;
@@ -2004,7 +2065,9 @@ export class ThreadSessionRuntime {
             })();
             let syntheticContext = '';
             if (input.username) {
-                syntheticContext += `<discord-user name="${input.username}" />`;
+                const msgAttr = input.sourceMessageId ? ` message-id="${input.sourceMessageId}"` : '';
+                const thrAttr = input.sourceThreadId ? ` thread-id="${input.sourceThreadId}"` : '';
+                syntheticContext += `<discord-user name="${input.username}"${msgAttr}${thrAttr} />`;
             }
             const parts = [
                 { type: 'text', text: promptWithImagePaths },
@@ -2112,6 +2175,8 @@ export class ThreadSessionRuntime {
             agent: input.agent,
             model: input.model,
             permissions: input.permissions,
+            sourceMessageId: input.sourceMessageId,
+            sourceThreadId: input.sourceThreadId,
             sessionStartScheduleKind: input.sessionStartSource?.scheduleKind,
             sessionStartScheduledTaskId: input.sessionStartSource?.scheduledTaskId,
         };
@@ -2281,10 +2346,50 @@ export class ThreadSessionRuntime {
             return this.tryDrainQueue({ showIndicator: true });
         });
     }
+    async abortActiveRunAndWait({ reason, timeoutMs = 2_000, }) {
+        const state = this.state;
+        const sessionId = state?.sessionId;
+        if (!sessionId) {
+            return;
+        }
+        let needsIdleWait = false;
+        const waitSinceTimestamp = Date.now();
+        const abortResult = await errore.tryAsync(() => {
+            return this.dispatchAction(async () => {
+                needsIdleWait = this.isMainSessionBusy();
+                const outcome = this.abortActiveRunInternal({ reason });
+                if (outcome.apiAbortPromise) {
+                    void outcome.apiAbortPromise;
+                }
+            });
+        });
+        if (abortResult instanceof Error) {
+            logger.error(`[ABORT WAIT] Failed to abort active run: ${abortResult.message}`);
+            return;
+        }
+        if (!needsIdleWait) {
+            return;
+        }
+        await this.waitForEvent({
+            predicate: (event) => {
+                return event.type === 'session.idle'
+                    && event.properties.sessionID === sessionId;
+            },
+            sinceTimestamp: waitSinceTimestamp,
+            timeoutMs,
+        });
+    }
     /** Number of messages waiting in the queue. */
     getQueueLength() {
         return this.state?.queueItems.length ?? 0;
     }
+    /** NOTIFY_MESSAGE_FLAGS unless queue has a next item, then SILENT.
+     * Permissions should NOT use this — they always notify. */
+    getNotifyFlags() {
+        return this.getQueueLength() > 0
+            ? SILENT_MESSAGE_FLAGS
+            : NOTIFY_MESSAGE_FLAGS;
+    }
     /** Clear all queued messages. */
     clearQueue() {
         threadState.clearQueueItems(this.threadId);
@@ -2501,7 +2606,9 @@ export class ThreadSessionRuntime {
         })();
         let syntheticContext = '';
         if (input.username) {
-            syntheticContext += `<discord-user name="${input.username}" />`;
+            const msgAttr = input.sourceMessageId ? ` message-id="${input.sourceMessageId}"` : '';
+            const thrAttr = input.sourceThreadId ? ` thread-id="${input.sourceThreadId}"` : '';
+            syntheticContext += `<discord-user name="${input.username}"${msgAttr}${thrAttr} />`;
         }
         const parts = [
             { type: 'text', text: promptWithImagePaths },
@@ -2706,7 +2813,6 @@ export class ThreadSessionRuntime {
             }
         }
         if (!session) {
-            const sessionTitle = prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt.slice(0, 80);
             // Pass per-session external_directory permissions so this session can
             // access its own project directory (and worktree origin if applicable)
             // without prompts. These override the server-level 'ask' default via
@@ -2720,12 +2826,18 @@ export class ThreadSessionRuntime {
                 }),
                 ...parsePermissionRules(permissions ?? []),
             ];
+            // Omit title so OpenCode auto-generates a summary from the conversation
             const sessionResponse = await getClient().session.create({
-                title: sessionTitle,
                 directory: this.sdkDirectory,
                 permission: sessionPermissions,
             });
             session = sessionResponse.data;
+            // Insert DB row immediately so the external-sync poller sees
+            // source='kimaki' before the next poll tick and skips this session.
+            // The upsert at the end of ensureSession is kept for the reuse path.
+            if (session) {
+                await setThreadSession(this.thread.id, session.id);
+            }
             createdNewSession = true;
         }
         if (!session) {
@@ -2813,7 +2925,7 @@ export class ThreadSessionRuntime {
                         if (m.info.role !== 'assistant') {
                             return false;
                         }
-                        if (!('tokens' in m.info) || !m.info.tokens) {
+                        if (!m.info.tokens) {
                             return false;
                         }
                         return getTokenTotal(m.info.tokens) > 0;
@@ -2852,9 +2964,8 @@ export class ThreadSessionRuntime {
         this.stopTyping();
         // Skip notification if there's a queued message next — the user only
         // needs to be notified when the entire queue finishes.
-        const queuedNext = (threadState.getThreadState(this.threadId)?.queueItems.length ?? 0) > 0;
         await sendThreadMessage(this.thread, footerText, {
-            flags: queuedNext ? SILENT_MESSAGE_FLAGS : NOTIFY_MESSAGE_FLAGS,
+            flags: this.getNotifyFlags(),
         });
         logger.log(`DURATION: Session completed in ${sessionDuration}, model ${runInfo.model}, tokens ${runInfo.tokensUsed}`);
     }

package/dist/store.js

@@ -5,6 +5,7 @@
 import { createStore } from 'zustand/vanilla';
 export const store = createStore(() => ({
     dataDir: null,
+    projectsDir: null,
     defaultVerbosity: 'text_and_essential_tools',
     defaultMentionMode: false,
     critiqueEnabled: true,

package/dist/system-message.js

@@ -54,6 +54,18 @@ bunx critique --web "Short title describing the changes" --filter "src/config.ts
 
 The string after \`--web\` becomes the diff page title — make it reflect what the changes do (e.g. "Add retry logic to API client", "Fix auth timeout bug").
 
+### fetching user comments from critique diffs
+
+Users can add line-level comments (annotations) on any critique diff page via the Agentation widget (bottom-right corner of the diff page). To read those comments:
+
+\`\`\`bash
+curl https://critique.work/v/<id>/annotations
+\`\`\`
+
+Returns \`text/markdown\` with each annotation showing the file, line, and comment text.
+Use this when the user says they left comments on a critique diff and you need to read them.
+You can also use WebFetch on \`https://critique.work/v/<id>/annotations\` to get the markdown directly.
+
 ### about critique
 
 critique is an open source tool (MIT license) at https://github.com/remorses/critique.
@@ -131,7 +143,7 @@ Use random tunnel IDs by default. Only pass \`-t\` when exposing a service that
 tmux new-session -d -s myapp-dev
 
 # Run the dev server with kimaki tunnel inside the session
-tmux send-keys -t myapp-dev "kimaki tunnel -p 3000 -- pnpm dev" Enter
+tmux send-keys -t myapp-dev "kimaki tunnel --kill -p 3000 -- pnpm dev" Enter
 \`\`\`
 
 ### getting the tunnel URL
@@ -146,15 +158,15 @@ tmux capture-pane -t myapp-dev -p | grep -i "tunnel"
 \`\`\`bash
 # Next.js project
 tmux new-session -d -s projectname-nextjs-dev-3000
-tmux send-keys -t nextjs-dev "kimaki tunnel -p 3000 -- pnpm dev" Enter
+tmux send-keys -t nextjs-dev "kimaki tunnel --kill -p 3000 -- pnpm dev" Enter
 
 # Vite project on port 5173
 tmux new-session -d -s vite-dev-5173
-tmux send-keys -t vite-dev "kimaki tunnel -p 5173 -- pnpm dev" Enter
+tmux send-keys -t vite-dev "kimaki tunnel --kill -p 5173 -- pnpm dev" Enter
 
 # Custom tunnel ID (only for intentionally public-safe services)
 tmux new-session -d -s holocron-dev
-tmux send-keys -t holocron-dev "kimaki tunnel -p 3000 -t holocron -- pnpm dev" Enter
+tmux send-keys -t holocron-dev "kimaki tunnel --kill -p 3000 -t holocron -- pnpm dev" Enter
 \`\`\`
 
 ### stopping the dev server
@@ -173,6 +185,12 @@ tmux kill-session -t myapp-dev
 tmux list-sessions
 \`\`\`
 `;
+export function isInjectedPromptMarker({ marker, }) {
+    if (!marker) {
+        return false;
+    }
+    return Boolean(marker.cliThreadPrompt || marker.start);
+}
 export function getOpencodeSystemMessage({ sessionId, channelId, guildId, threadId, worktree, channelTopic, username, userId, agents, currentAgent, }) {
     const agentFlag = currentAgent ? ` --agent ${currentAgent}` : '';
     const topicContext = channelTopic?.trim()

package/dist/system-message.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vitest';
+import { isInjectedPromptMarker } from './system-message.js';
+describe('isInjectedPromptMarker', () => {
+    test('treats start markers as injected prompts', () => {
+        expect(isInjectedPromptMarker({
+            marker: { start: true },
+        })).toBe(true);
+    });
+    test('treats cli thread prompt markers as injected prompts', () => {
+        expect(isInjectedPromptMarker({
+            marker: { cliThreadPrompt: true },
+        })).toBe(true);
+    });
+    test('ignores messages without an injection marker', () => {
+        expect(isInjectedPromptMarker({
+            marker: { scheduledKind: 'cron', scheduledTaskId: 1 },
+        })).toBe(false);
+    });
+});

package/dist/task-runner.js

@@ -21,7 +21,7 @@ function parseMessageId(value) {
 }
 async function executeThreadScheduledTask({ rest, task, payload, }) {
     const marker = {
-        cliThreadPrompt: true,
+        start: true,
         scheduledKind: task.schedule_kind,
         scheduledTaskId: task.id,
         ...(payload.agent ? { agent: payload.agent } : {}),

package/dist/thread-message-queue.e2e.test.js

@@ -394,20 +394,15 @@ e2eTest('thread message queue ordering', () => {
         await waitForFooterMessage({
             discord,
             threadId: thread.id,
-            timeout: 4_000,
+            timeout: 8_000,
             afterMessageIncludes: 'beta',
             afterAuthorId: TEST_USER_ID,
         });
-        expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: alpha
-        --- from: assistant (TestBot)
-        ⬥ ok
-        --- from: user (queue-tester)
-        Reply with exactly: beta
-        --- from: assistant (TestBot)
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
+        const timeline = await th.text();
+        expect(timeline).toContain('Reply with exactly: alpha');
+        expect(timeline).toContain('Reply with exactly: beta');
+        expect(timeline).toContain('⬥ ok');
+        expect(timeline).toContain('*project ⋅ main ⋅');
         // User B's message must appear before the new bot response
         const userBIndex = after.findIndex((m) => {
             return (m.author.id === TEST_USER_ID &&
@@ -422,7 +417,7 @@ e2eTest('thread message queue ordering', () => {
         // New bot response has non-empty content
         const newBotReply = afterBotMessages[afterBotMessages.length - 1];
         expect(newBotReply.content.trim().length).toBeGreaterThan(0);
-    }, 8_000);
+    }, 12_000);
     test('two rapid text messages in thread — both processed in order', async () => {
         // 1. Send initial message to text channel → thread + session established
         await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
@@ -820,11 +815,10 @@ e2eTest('thread message queue ordering', () => {
         Reply with exactly: echo
         --- from: assistant (TestBot)
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        ⬥ ok
         --- from: user (queue-tester)
         Reply with exactly: foxtrot
         --- from: assistant (TestBot)
-        ⬥ ok
-        ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(userEchoIndex).toBeGreaterThan(-1);

package/dist/tools.js

@@ -106,7 +106,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                 }
                 try {
                     const session = await getClient().session.create({
-                        title: title || message.slice(0, 50),
+                        ...(title ? { title } : {}),
                     });
                     if (!session.data) {
                         throw new Error('Failed to create session');