kimaki 0.27.0 → 0.28.0

package/dist/discord-command-registration.js

@@ -34,6 +34,21 @@ async function clearGlobalCommands({ rest, appId, }) {
 function truncateCommandDescription(description) {
     return description.slice(0, 100);
 }
+export function buildQuickAgentSlashCommand({ commandName, description, }) {
+    return new SlashCommandBuilder()
+        .setName(commandName)
+        .setDescription(truncateCommandDescription(description))
+        .setDMPermission(false)
+        .addStringOption((opt) => opt
+        .setName('prompt')
+        .setDescription('Send a prompt with this agent')
+        .setRequired(false))
+        .addStringOption((opt) => opt
+        .setName('variant')
+        .setDescription('Model thinking level for this agent')
+        .setRequired(false)
+        .setAutocomplete(true));
+}
 export async function registerCommands({ token, appId, guildIds, userCommands = [], agents = [], }) {
     const commands = [
         new SlashCommandBuilder()
@@ -373,15 +388,7 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             agentName: agent.name,
             description: agent.description,
         });
-        commands.push(new SlashCommandBuilder()
-            .setName(commandName)
-            .setDescription(truncateCommandDescription(description))
-            .setDMPermission(false)
-            .addStringOption((opt) => opt
-            .setName('prompt')
-            .setDescription('Send a prompt with this agent')
-            .setRequired(false))
-            .toJSON());
+        commands.push(buildQuickAgentSlashCommand({ commandName, description }).toJSON());
     }
     // 2. User-defined commands, MCP prompts, and skills (ordered by priority)
     // Also populate registeredUserCommands in the store for /queue-command autocomplete

package/dist/discord-command-registration.test.js

@@ -0,0 +1,17 @@
+// Tests Discord slash command payloads for quick agent commands.
+import { describe, expect, test } from 'vitest';
+import { buildQuickAgentSlashCommand } from './discord-command-registration.js';
+describe('buildQuickAgentSlashCommand', () => {
+    test('puts variant last after prompt', () => {
+        const command = buildQuickAgentSlashCommand({
+            commandName: 'plan-agent',
+            description: 'Switch to plan agent',
+        }).toJSON();
+        expect(command.options?.map((option) => option.name)).toMatchInlineSnapshot(`
+      [
+        "prompt",
+        "variant",
+      ]
+    `);
+    });
+});

package/dist/discord-utils.js

@@ -9,6 +9,7 @@ const { ChannelType, GuildMember, MessageFlags, PermissionsBitField, REST, Route
 import { discordApiUrl } from './discord-urls.js';
 import { Lexer } from 'marked';
 import { splitTablesFromMarkdown } from './format-tables.js';
+import { sessionPartContent, shouldLeadWithBlankLine, } from './message-formatting.js';
 import { getChannelDirectory, getThreadWorktreeOrWorkspace } from './database.js';
 import { DiscordOperationError } from './errors.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
@@ -222,6 +223,68 @@ export async function ensureThreadMember({ rest, threadId, userId, }) {
     if (addMemberResult instanceof Error)
         return addMemberResult;
 }
+export function resolveFooterMentionUserId({ sessionUserId, botUserId, threadOwnerId, members, }) {
+    if (sessionUserId && sessionUserId !== botUserId)
+        return sessionUserId;
+    if (!botUserId || threadOwnerId !== botUserId)
+        return undefined;
+    const humans = members
+        .filter((member) => member.id && member.id !== botUserId && member.bot === false)
+        .sort((a, b) => {
+        const aJoined = a.joinedTimestamp ?? Number.POSITIVE_INFINITY;
+        const bJoined = b.joinedTimestamp ?? Number.POSITIVE_INFINITY;
+        if (aJoined !== bJoined)
+            return aJoined - bJoined;
+        return a.id.localeCompare(b.id);
+    });
+    return humans[0]?.id;
+}
+function footerMentionMembersFromCache(thread) {
+    return [...thread.members.cache.values()].map((member) => ({
+        id: member.id,
+        bot: member.user?.bot,
+        joinedTimestamp: member.joinedTimestamp ?? null,
+    }));
+}
+export async function resolveThreadFooterMentionUserId({ sessionUserId, thread, }) {
+    const botUserId = thread.client.user?.id;
+    if (sessionUserId && sessionUserId !== botUserId)
+        return sessionUserId;
+    if (!botUserId || thread.ownerId !== botUserId)
+        return undefined;
+    const cached = footerMentionMembersFromCache(thread);
+    if (cached.some((member) => member.bot === false && member.id !== botUserId)) {
+        return resolveFooterMentionUserId({
+            sessionUserId,
+            botUserId,
+            threadOwnerId: thread.ownerId ?? undefined,
+            members: cached,
+        });
+    }
+    const fetched = await thread.members.fetch().catch((e) => {
+        return new DiscordOperationError({ operation: 'fetchThreadMembers', cause: e });
+    });
+    if (fetched instanceof Error) {
+        discordLogger.warn(`[FOOTER] Failed to fetch thread members: ${fetched.message}`);
+        return resolveFooterMentionUserId({
+            sessionUserId,
+            botUserId,
+            threadOwnerId: thread.ownerId ?? undefined,
+            members: cached,
+        });
+    }
+    const members = [...fetched.values()].map((member) => ({
+        id: member.id,
+        bot: member.user?.bot,
+        joinedTimestamp: member.joinedTimestamp ?? null,
+    }));
+    return resolveFooterMentionUserId({
+        sessionUserId,
+        botUserId,
+        threadOwnerId: thread.ownerId ?? undefined,
+        members,
+    });
+}
 /** Remove Discord mentions from text so they don't appear in thread titles */
 export function stripMentions(text) {
     return text
@@ -517,6 +580,27 @@ export async function sendThreadMessage(thread, content, options) {
     }
     return firstMessage;
 }
+export async function sendSessionPartMessage(thread, content, options) {
+    return sendThreadMessage(thread, sessionPartContent({
+        content,
+        leadWithBlankLine: options?.leadWithBlankLine === true,
+    }), { flags: options?.flags });
+}
+export async function sendSessionPartBatches({ thread, batches, }) {
+    const sent = [];
+    let previousKind;
+    for (const batch of batches) {
+        const message = await sendSessionPartMessage(thread, batch.content, {
+            leadWithBlankLine: shouldLeadWithBlankLine({
+                previousKind,
+                nextKind: batch.kind,
+            }),
+        });
+        previousKind = batch.kind;
+        sent.push({ partIds: batch.partIds, message });
+    }
+    return sent;
+}
 export function isThreadChannelType(type) {
     return [
         ChannelType.PublicThread,

package/dist/discord-utils.test.js

@@ -1,6 +1,6 @@
 import { PermissionsBitField } from 'discord.js';
 import { afterEach, describe, expect, test } from 'vitest';
-import { hasKimakiAdminPermission, hasKimakiBotPermission, raceDiscordRename, resolveGuildMessageMember, splitMarkdownForDiscord, } from './discord-utils.js';
+import { hasKimakiAdminPermission, hasKimakiBotPermission, raceDiscordRename, resolveFooterMentionUserId, resolveGuildMessageMember, resolveThreadFooterMentionUserId, splitMarkdownForDiscord, } from './discord-utils.js';
 import { store } from './store.js';
 describe('splitMarkdownForDiscord', () => {
     test('never returns chunks over the max length with code fences', () => {
@@ -248,6 +248,140 @@ describe('resolveGuildMessageMember', () => {
         await expect(resolveGuildMessageMember(message)).resolves.toBe(null);
     });
 });
+describe('resolveFooterMentionUserId', () => {
+    test('uses the session user when it is not the bot', () => {
+        expect(resolveFooterMentionUserId({
+            sessionUserId: 'user-1',
+            botUserId: 'bot-1',
+            threadOwnerId: 'bot-1',
+            members: [
+                { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+                { id: 'user-2', bot: false, joinedTimestamp: 2 },
+            ],
+        })).toBe('user-1');
+    });
+    test('skips bots and uses the earliest human member when the bot created the thread', () => {
+        expect(resolveFooterMentionUserId({
+            sessionUserId: 'bot-1',
+            botUserId: 'bot-1',
+            threadOwnerId: 'bot-1',
+            members: [
+                { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+                { id: 'other-bot', bot: true, joinedTimestamp: 2 },
+                { id: 'user-3', bot: false, joinedTimestamp: 4 },
+                { id: 'user-2', bot: false, joinedTimestamp: 3 },
+            ],
+        })).toBe('user-2');
+    });
+    test('does not mention anyone when the bot created the thread and no human member exists', () => {
+        expect(resolveFooterMentionUserId({
+            sessionUserId: 'bot-1',
+            botUserId: 'bot-1',
+            threadOwnerId: 'bot-1',
+            members: [
+                { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+                { id: 'other-bot', bot: true, joinedTimestamp: 2 },
+            ],
+        })).toBeUndefined();
+    });
+    test('uses the first human member when the bot created the thread and no session user is set', () => {
+        expect(resolveFooterMentionUserId({
+            sessionUserId: undefined,
+            botUserId: 'bot-1',
+            threadOwnerId: 'bot-1',
+            members: [
+                { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+                { id: 'user-2', bot: false, joinedTimestamp: 2 },
+            ],
+        })).toBe('user-2');
+    });
+    test('does not mention a member whose bot flag is unknown', () => {
+        expect(resolveFooterMentionUserId({
+            sessionUserId: undefined,
+            botUserId: 'bot-1',
+            threadOwnerId: 'bot-1',
+            members: [
+                { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+                { id: 'maybe-user', joinedTimestamp: 2 },
+            ],
+        })).toBeUndefined();
+    });
+});
+function fakeThread({ ownerId, botUserId, members, onFetch, }) {
+    const cache = new Map(members.map((member) => [
+        member.id,
+        {
+            id: member.id,
+            user: member.bot === undefined ? undefined : { bot: member.bot },
+            joinedTimestamp: member.joinedTimestamp ?? null,
+        },
+    ]));
+    return {
+        ownerId,
+        client: { user: { id: botUserId } },
+        members: {
+            cache,
+            fetch: onFetch ?? (() => {
+                throw new Error('should not fetch thread members');
+            }),
+        },
+    };
+}
+describe('resolveThreadFooterMentionUserId', () => {
+    test('does not fetch when a human session user is already known', async () => {
+        await expect(resolveThreadFooterMentionUserId({
+            sessionUserId: 'user-1',
+            thread: fakeThread({
+                ownerId: 'bot-1',
+                botUserId: 'bot-1',
+                members: [{ id: 'bot-1', bot: true }],
+            }),
+        })).resolves.toBe('user-1');
+    });
+    test('does not fetch when the thread owner is not the bot', async () => {
+        await expect(resolveThreadFooterMentionUserId({
+            sessionUserId: undefined,
+            thread: fakeThread({
+                ownerId: 'user-1',
+                botUserId: 'bot-1',
+                members: [{ id: 'user-1', bot: false }],
+            }),
+        })).resolves.toBeUndefined();
+    });
+    test('uses cached humans without fetching', async () => {
+        await expect(resolveThreadFooterMentionUserId({
+            sessionUserId: undefined,
+            thread: fakeThread({
+                ownerId: 'bot-1',
+                botUserId: 'bot-1',
+                members: [
+                    { id: 'bot-1', bot: true, joinedTimestamp: 1 },
+                    { id: 'user-2', bot: false, joinedTimestamp: 2 },
+                ],
+            }),
+        })).resolves.toBe('user-2');
+    });
+    test('fetches only when the bot owns the thread and no human is cached', async () => {
+        let fetched = false;
+        const thread = fakeThread({
+            ownerId: 'bot-1',
+            botUserId: 'bot-1',
+            members: [{ id: 'bot-1', bot: true, joinedTimestamp: 1 }],
+            onFetch: async () => {
+                fetched = true;
+                return new Map([
+                    ['bot-1', { id: 'bot-1', user: { bot: true }, joinedTimestamp: 1 }],
+                    ['user-2', { id: 'user-2', user: { bot: false }, joinedTimestamp: 2 }],
+                ]);
+            },
+        });
+        await expect(resolveThreadFooterMentionUserId({
+            sessionUserId: undefined,
+            thread,
+        })).resolves.toBe('user-2');
+        expect(fetched).toBe(true);
+    });
+});
 describe('raceDiscordRename', () => {
     test('returns timeout when rename hangs', async () => {
         const result = await raceDiscordRename({

package/dist/errors.js

@@ -20,6 +20,11 @@ export class ServerNotReadyError extends errore.createTaggedError({
     message: 'OpenCode client for directory "$directory" is not available because the shared server is not ready',
 }) {
 }
+export class OpencodeIncompatibleVersionError extends errore.createTaggedError({
+    name: 'OpencodeIncompatibleVersionError',
+    message: 'Kimaki is not compatible with OpenCode version $version. Install an OpenCode 1.x release.',
+}) {
+}
 export class ApiKeyMissingError extends errore.createTaggedError({
     name: 'ApiKeyMissingError',
     message: '$service API key is required',

package/dist/external-directory-permissions.e2e.test.js

@@ -64,18 +64,22 @@ describe('external directory permissions', () => {
       "--- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER first
       --- from: assistant (TestBot)
-      *using deterministic-provider/deterministic-v2*
-      ⬥ reading external directory
+      > *using deterministic-provider/deterministic-v2*
+      > reading external directory
+
       ┣ read *probe.txt*
-      ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
+
+      > external-directory-probe-done
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
       --- from: user (external-directory-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER followup
       --- from: assistant (TestBot)
-      ⬥ reading external directory
+      > reading external directory
+
       ┣ read *probe.txt*
-      ⬥ external-directory-probe-done
-      *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
+
+      > external-directory-probe-done
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
     `);
         expect(text).not.toContain('Permission Required');
     });

package/dist/external-directory-project-deny.e2e.test.js

@@ -54,10 +54,12 @@ describe('external directory project deny', () => {
       "--- from: user (external-directory-deny-tester)
       EXTERNAL_DIRECTORY_PROBE_MARKER denied
       --- from: assistant (TestBot)
-      *using deterministic-provider/deterministic-v2*
-      ⬥ reading external directory
+      > *using deterministic-provider/deterministic-v2*
+      > reading external directory
+
       ┣ read *probe.txt*
-      ⬥ external-directory-probe-denied"
+
+      > external-directory-probe-denied"
     `);
         // A deny is silent: it must not fall back to asking the user.
         expect(text).not.toContain('Permission Required');

package/dist/external-opencode-sync.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
 import { getChannelVerbosity, getPartMessageIds, getThreadIdBySessionId, getThreadSessionSource, listTrackedTextChannels, setPartMessagesBatch, upsertThreadSession, } from './database.js';
-import { sendThreadMessage } from './discord-utils.js';
+import { sendSessionPartBatches } from './discord-utils.js';
 import { createLogger, LogPrefix } from './logger.js';
-import { formatPart, collectSessionChunks, batchChunksForDiscord, } from './message-formatting.js';
+import { formatPart, collectSessionChunks, batchChunksForDiscord, QUEUE_PREFIX, } from './message-formatting.js';
 import { initializeOpencodeForDirectory, } from './opencode.js';
-import { isEssentialToolPart } from './session-handler/thread-session-runtime.js';
+import { getRuntime, isEssentialToolPart } from './session-handler/thread-session-runtime.js';
 import { notifyError } from './sentry.js';
 import { store } from './store.js';
 import { extractNonXmlContent } from './xml.js';
@@ -20,8 +20,7 @@ const SYNC_PER_DIRECTORY_TIMEOUT_MS = 30_000;
 const CLI_START_MS = Date.now() - 5 * 60 * 1000;
 let externalSyncInterval = null;
 function isSyntheticTextPart(part) {
-    const candidate = part;
-    return candidate.synthetic === true;
+    return part.synthetic === true;
 }
 function parseDiscordOriginMetadata(text) {
     const match = text.match(/<discord-user\s+([^>]+)\s*\/>/);
@@ -64,7 +63,7 @@ function getDiscordOriginMetadataFromMessage({ message, }) {
     }
     return null;
 }
-function getRenderableUserTextParts({ message, }) {
+export function getRenderableUserTextParts({ message, }) {
     if (message.info.role !== 'user') {
         return [];
     }
@@ -72,7 +71,7 @@ function getRenderableUserTextParts({ message, }) {
         if (part.type !== 'text') {
             return [];
         }
-        if (isSyntheticTextPart(part)) {
+        if (isSyntheticTextPart(part) || part.ignored === true) {
             return [];
         }
         const cleanedText = extractNonXmlContent(part.text || '').trim();
@@ -82,8 +81,49 @@ function getRenderableUserTextParts({ message, }) {
         return [{ id: part.id, text: cleanedText }];
     });
 }
+function hasCompactionContinueMetadata(part) {
+    return part.metadata?.compaction_continue === true;
+}
+export function isInternalOpenCodeUserMessage({ message, }) {
+    if (message.info.role !== 'user') {
+        return false;
+    }
+    return message.parts.some((part) => {
+        if (part.type === 'compaction') {
+            return true;
+        }
+        if (part.type !== 'text') {
+            return false;
+        }
+        return isSyntheticTextPart(part) && hasCompactionContinueMetadata(part);
+    });
+}
+export function shouldSkipExternalAssistantMessage({ message, }) {
+    if (message.info.role !== 'assistant') {
+        return false;
+    }
+    return message.info.summary === true;
+}
+export function getIgnoredNoticeTextParts({ message, }) {
+    if (message.info.role !== 'user') {
+        return [];
+    }
+    return message.parts.flatMap((part) => {
+        if (part.type !== 'text') {
+            return [];
+        }
+        if (part.ignored !== true || isSyntheticTextPart(part)) {
+            return [];
+        }
+        const text = part.text?.trim();
+        if (!text) {
+            return [];
+        }
+        return [{ id: part.id, text }];
+    });
+}
 function getExternalUserMirrorText({ username, prompt, }) {
-    return `» **${username}:** ${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
+    return `${QUEUE_PREFIX}**${username}:** ${prompt.slice(0, 1000)}${prompt.length > 1000 ? '...' : ''}`;
 }
 // Pure derivation: is the latest user turn from Discord?
 // Checks the newest user message with renderable text for a <discord-user />
@@ -91,12 +131,15 @@ function getExternalUserMirrorText({ username, prompt, }) {
 // (kimaki manages it) and external sync should skip it. If absent (CLI/TUI),
 // external sync should mirror it — this naturally handles the "reclaim" case
 // (external → discord → external) without any DB source toggling.
-function isLatestUserTurnFromDiscord({ messages, }) {
+export function isLatestUserTurnFromDiscord({ messages, }) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
         if (message.info.role !== 'user') {
             continue;
         }
+        if (isInternalOpenCodeUserMessage({ message })) {
+            continue;
+        }
         const renderableParts = getRenderableUserTextParts({ message });
         if (renderableParts.length === 0) {
             continue;
@@ -234,6 +277,23 @@ function collectUnsyncedChunks({ messages, syncedPartIds, verbosity, thread, })
     const directMappings = [];
     for (const message of messages) {
         if (message.info.role === 'user') {
+            if (isInternalOpenCodeUserMessage({ message })) {
+                continue;
+            }
+            const ignoredNoticeParts = getIgnoredNoticeTextParts({ message }).filter((part) => {
+                return !syncedPartIds.has(part.id);
+            });
+            if (ignoredNoticeParts.length > 0) {
+                chunks.push({
+                    partIds: ignoredNoticeParts.map((part) => {
+                        return part.id;
+                    }),
+                    content: ignoredNoticeParts.map((part) => {
+                        return part.text;
+                    }).join('\n\n'),
+                    kind: 'text',
+                });
+            }
             const renderableParts = getRenderableUserTextParts({ message });
             const unsyncedParts = renderableParts.filter((p) => {
                 return !syncedPartIds.has(p.id);
@@ -265,12 +325,16 @@ function collectUnsyncedChunks({ messages, syncedPartIds, verbosity, thread, })
                     return p.id;
                 }),
                 content: getExternalUserMirrorText({ username: 'user', prompt: promptText }),
+                kind: 'text',
             });
             continue;
         }
         if (message.info.role !== 'assistant') {
             continue;
         }
+        if (shouldSkipExternalAssistantMessage({ message })) {
+            continue;
+        }
         // Filter assistant parts by verbosity before passing to shared collector
         const filteredParts = message.parts.filter((part) => {
             return shouldMirrorAssistantPart({ part, verbosity });
@@ -314,6 +378,10 @@ async function syncSessionToThread({ client, discordClient, directory, channelId
     if (isLatestUserTurnFromDiscord({ messages })) {
         return;
     }
+    const existingThreadId = await getThreadIdBySessionId(sessionId);
+    if (existingThreadId && getRuntime(existingThreadId)) {
+        return;
+    }
     const thread = await ensureExternalSessionThread({
         discordClient,
         channelId,
@@ -340,13 +408,15 @@ async function syncSessionToThread({ client, discordClient, directory, channelId
         await setPartMessagesBatch(directMappings);
     }
     const batched = batchChunksForDiscord(chunks);
-    for (const batch of batched) {
+    if (signal.aborted)
+        return;
+    const sent = await sendSessionPartBatches({ thread, batches: batched });
+    for (const batch of sent) {
         if (signal.aborted)
             return;
-        const sentMessage = await sendThreadMessage(thread, batch.content);
         await setPartMessagesBatch(batch.partIds.map((partId) => ({
             partId,
-            messageId: sentMessage.id,
+            messageId: batch.message.id,
             threadId: thread.id,
         })));
     }
@@ -377,6 +447,15 @@ async function pulseTypingForBusySessions({ discordClient, statuses, }) {
     }
 }
 const EXTERNAL_SYNC_MAX_SESSIONS = 50;
+export function isExternalSyncRootSession({ title, parentID, }) {
+    if (parentID) {
+        return false;
+    }
+    if (/^new session\s*-/i.test(title || '')) {
+        return false;
+    }
+    return !/subagent\)\s*$/i.test(title || '');
+}
 // Tracks directories with an in-flight sync. When a directory times out,
 // its AbortController is aborted so the inner work stops producing side
 // effects (Discord messages, DB writes). The next poll tick skips the
@@ -449,11 +528,7 @@ async function syncDirectoryInner({ directory, channelId, startMs, discordClient
     if (signal.aborted)
         return;
     const sessions = (sessionsResponse.data || []).filter((session) => {
-        const title = session.title || '';
-        if (/^new session\s*-/i.test(title)) {
-            return false;
-        }
-        return !/subagent\)\s*$/i.test(title);
+        return isExternalSyncRootSession(session);
     });
     const sorted = sortSessionsByRecency(sessions);
     for (const session of sorted) {
@@ -540,4 +615,6 @@ export const externalOpencodeSyncInternals = {
     parseDiscordOriginMetadata,
     getDiscordOriginMetadataFromMessage,
     isLatestUserTurnFromDiscord,
+    isInternalOpenCodeUserMessage,
+    shouldSkipExternalAssistantMessage,
 };