kimaki 0.18.0 → 0.20.0

package/dist/cli-commands/project.js

@@ -56,74 +56,7 @@ cli
         void client.login(botToken);
     });
     cliLogger.log('Finding guild...');
-    // Find guild
-    let guild;
-    if (options.guild) {
-        const guildId = String(options.guild);
-        const foundGuild = client.guilds.cache.get(guildId);
-        if (!foundGuild) {
-            cliLogger.log('Guild not found');
-            cliLogger.error(`Guild not found: ${guildId}`);
-            void client.destroy();
-            process.exit(EXIT_NO_RESTART);
-        }
-        guild = foundGuild;
-    }
-    else {
-        const existingChannelId = await (await getDb()).query.channel_directories.findFirst({
-            where: { channel_type: 'text' },
-            orderBy: { created_at: 'desc' },
-            columns: { channel_id: true },
-        }).then((row) => row?.channel_id);
-        if (existingChannelId) {
-            try {
-                const ch = await client.channels.fetch(existingChannelId);
-                if (ch && !ch.isDMBased()) {
-                    guild = ch.guild;
-                }
-                else {
-                    throw new Error('Channel has no guild');
-                }
-            }
-            catch (error) {
-                cliLogger.debug('Failed to fetch existing channel while selecting guild:', error instanceof Error ? error.stack : String(error));
-                let firstGuild = client.guilds.cache.first();
-                if (!firstGuild) {
-                    // Cache might be empty, try fetching guilds from API
-                    const fetched = await client.guilds.fetch();
-                    const firstOAuth2Guild = fetched.first();
-                    if (firstOAuth2Guild) {
-                        firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
-                    }
-                }
-                if (!firstGuild) {
-                    cliLogger.log('No guild found');
-                    cliLogger.error('No guild found. Add the bot to a server first.');
-                    void client.destroy();
-                    process.exit(EXIT_NO_RESTART);
-                }
-                guild = firstGuild;
-            }
-        }
-        else {
-            let firstGuild = client.guilds.cache.first();
-            if (!firstGuild) {
-                // Cache might be empty, try fetching guilds from API
-                const fetched = await client.guilds.fetch();
-                const firstOAuth2Guild = fetched.first();
-                if (firstOAuth2Guild) {
-                    firstGuild = await client.guilds.fetch(firstOAuth2Guild.id);
-                }
-            }
-            if (!firstGuild) {
-                cliLogger.log('No guild found');
-                cliLogger.error('No guild found. Add the bot to a server first.');
-                void client.destroy();
-                process.exit(EXIT_NO_RESTART);
-            }
-            guild = firstGuild;
-        }
-    }
+    const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
     // Check if channel already exists in this guild
     cliLogger.log('Checking for existing channel...');
     try {
@@ -353,25 +286,7 @@ cli
         client.once(Events.Error, reject);
         client.login(botToken).catch(reject);
     });
-    let guild;
-    if (options.guild) {
-        const found = client.guilds.cache.get(options.guild);
-        if (!found) {
-            cliLogger.error(`Guild not found: ${options.guild}`);
-            void client.destroy();
-            process.exit(EXIT_NO_RESTART);
-        }
-        guild = found;
-    }
-    else {
-        const first = client.guilds.cache.first();
-        if (!first) {
-            cliLogger.error('No guild found. Add the bot to a server first.');
-            void client.destroy();
-            process.exit(EXIT_NO_RESTART);
-        }
-        guild = first;
-    }
+    const guild = await resolveGuildForProjectCommand({ client, guildIdOverride: options.guild });
     const { textChannelId, channelName } = await createProjectChannels({
         guild,
         projectDirectory,
@@ -383,4 +298,87 @@ cli
     cliLogger.log(channelUrl);
     process.exit(0);
 });
+// Resolve the guild for project add/create commands. In gateway mode the
+// guild cache only contains authorized guilds, so picking from cache is safe.
+// The old approach fetched an existing channel to infer the guild, but that
+// breaks when the channel belongs to a different guild (e.g. old self-hosted
+// bot channels) and the gateway proxy rejects the REST call. This led to a
+// non-deterministic fallback that picked the wrong guild.
+async function resolveGuildForProjectCommand({ client, guildIdOverride }) {
+    if (guildIdOverride) {
+        const found = client.guilds.cache.get(guildIdOverride);
+        if (!found) {
+            cliLogger.error(`Guild not found: ${guildIdOverride}`);
+            void client.destroy();
+            process.exit(EXIT_NO_RESTART);
+        }
+        return found;
+    }
+    // Try existing channel lookup to find the guild the user already has channels in.
+    // This handles multi-guild setups where we want to add to the same guild.
+    const db = await getDb();
+    const existingChannels = await db.query.channel_directories.findMany({
+        where: { channel_type: 'text' },
+        orderBy: { created_at: 'desc' },
+        columns: { channel_id: true },
+        limit: 20,
+    });
+    // Log available guilds for debugging guild selection issues
+    const cachedGuilds = Array.from(client.guilds.cache.values());
+    cliLogger.debug(`Guilds in cache (${cachedGuilds.length}): ${cachedGuilds.map((g) => `${g.name} (${g.id})`).join(', ')}`);
+    // When multiple guilds are available, find which guild has the most
+    // existing channels. The user's main guild will have far more channels
+    // than a test/demo guild.
+    const guildHits = new Map();
+    for (const row of existingChannels) {
+        try {
+            const ch = await client.channels.fetch(row.channel_id);
+            if (ch && !ch.isDMBased()) {
+                const entry = guildHits.get(ch.guild.id);
+                if (entry) {
+                    entry.count++;
+                }
+                else {
+                    guildHits.set(ch.guild.id, { guild: ch.guild, count: 1 });
+                }
+            }
+        }
+        catch {
+            // Channel might be in a different guild (gateway proxy rejects) or deleted, skip
+        }
+    }
+    if (guildHits.size > 0) {
+        // Pick the guild with the most channels
+        const best = Array.from(guildHits.values()).sort((a, b) => b.count - a.count)[0];
+        cliLogger.debug(`Guild channel counts: ${Array.from(guildHits.values()).map((e) => `${e.guild.name} (${e.guild.id}): ${e.count}`).join(', ')}`);
+        cliLogger.debug(`Selected guild: ${best.guild.name} (${best.guild.id}) with ${best.count} channels`);
+        return best.guild;
+    }
+    cliLogger.debug('Could not resolve guild from existing channels, falling back to cache');
+    // If only one guild in cache, use it directly (common case).
+    // If multiple guilds, error out and ask the user to specify --guild
+    // since we can't determine which one to use.
+    if (cachedGuilds.length === 1) {
+        return cachedGuilds[0];
+    }
+    if (cachedGuilds.length > 1) {
+        cliLogger.error(`Multiple guilds found. Use --guild to specify which one:\n${cachedGuilds.map((g) => `  ${g.id}  ${g.name}`).join('\n')}`);
+        void client.destroy();
+        process.exit(EXIT_NO_RESTART);
+    }
+    // Cache empty, try fetching
+    const fetched = await client.guilds.fetch();
+    if (fetched.size === 1) {
+        const firstOAuth2Guild = fetched.first();
+        return await client.guilds.fetch(firstOAuth2Guild.id);
+    }
+    if (fetched.size > 1) {
+        cliLogger.error(`Multiple guilds found. Use --guild to specify which one:\n${Array.from(fetched.values()).map((g) => `  ${g.id}  ${g.name}`).join('\n')}`);
+        void client.destroy();
+        process.exit(EXIT_NO_RESTART);
+    }
+    cliLogger.error('No guild found. Add the bot to a server first.');
+    void client.destroy();
+    process.exit(EXIT_NO_RESTART);
+}
 export default cli;

package/dist/cli-commands/send.js

@@ -1,4 +1,8 @@
 // Terminal send command for creating Discord threads and scheduling prompts.
+// Designed to work in CI/headless environments with just KIMAKI_BOT_TOKEN.
+// The local SQLite database (channel_directories) is NOT required for the basic
+// flow: post message → create thread → remote bot picks it up. The local project
+// directory mapping is only needed for --send-at, --wait, and --cwd.
 import { goke } from 'goke';
 import { z } from 'zod';
 import { note } from '@clack/prompts';
@@ -271,9 +275,18 @@ cli
             if (!threadData.parent_id) {
                 throw new Error(`Thread has no parent channel: ${targetThreadId}`);
             }
+            // channelConfig is optional: in CI/headless environments the local DB
+            // has no channel_directories rows because the bot hasn't synced yet.
+            // The running bot on the other end resolves the directory from its own DB.
+            // We only require it for features that genuinely need a local directory
+            // (scheduled tasks and --wait).
             const channelConfig = await getChannelDirectory(threadData.parent_id);
-            if (!channelConfig) {
-                throw new Error('Thread parent channel is not configured with a project directory');
+            // Guard early: fail before sending the message if a feature that
+            // needs local project directory mapping is requested.
+            if (!channelConfig && (parsedSchedule || options.wait)) {
+                const flag = parsedSchedule ? '--send-at' : '--wait';
+                throw new Error('Thread parent channel is not configured with a project directory. ' +
+                    `${flag} requires a local project mapping. Run the bot first to sync channel data.`);
             }
             if (parsedSchedule) {
                 const payload = {
@@ -298,6 +311,7 @@ cli
                     channelId: threadData.parent_id,
                     threadId: targetThreadId,
                     sessionId: sessionId || undefined,
+                    // channelConfig is guaranteed: early guard threw if missing with --send-at
                     projectDirectory: channelConfig.directory,
                 });
                 const threadUrl = `https://discord.com/channels/${threadData.guild_id}/${threadData.id}`;
@@ -337,6 +351,8 @@ cli
                 process.stdout.write(`Session: ${existingSessionId}\n`);
             process.stdout.write(`${threadUrl}\n`);
             if (options.wait) {
+                // channelConfig is guaranteed here: early guard above already
+                // threw if channelConfig is missing when --wait is used.
                 const { waitAndOutputSession } = await import('../wait-session.js');
                 await waitAndOutputSession({
                     threadId: targetThreadId,
@@ -352,17 +368,25 @@ cli
         }
         // Get channel info to extract directory from topic
         const channelData = (await rest.get(Routes.channel(channelId)));
+        // channelConfig is optional: in CI/headless environments the local DB
+        // has no channel_directories rows because the bot hasn't synced yet.
+        // The running bot on the other end resolves the directory from its own DB.
+        // We only require it for features that genuinely need a local directory
+        // (--send-at, --wait, --cwd).
         const channelConfig = await getChannelDirectory(channelData.id);
-        if (!channelConfig && !notifyOnly) {
-            cliLogger.log('Channel not configured');
-            throw new Error(`Channel #${channelData.name} is not configured with a project directory. Run the bot first to sync channel data.`);
-        }
         const projectDirectory = channelConfig?.directory;
+        // Features that require a local project directory mapping
+        const needsProjectDirectory = Boolean(parsedSchedule || options.wait || options.cwd);
+        if (!channelConfig && needsProjectDirectory) {
+            throw new Error(`Channel #${channelData.name} is not configured with a project directory. ` +
+                `${parsedSchedule ? '--send-at' : options.wait ? '--wait' : '--cwd'} requires a local project mapping. ` +
+                'Run the bot first to sync channel data.');
+        }
         // Validate --cwd is inside the project or an existing git worktree.
         let resolvedCwd;
         if (options.cwd) {
-            // projectDirectory is guaranteed here: --cwd is incompatible with --notify-only,
-            // and non-notify sends already require channelConfig above.
+            // projectDirectory is guaranteed here: needsProjectDirectory check above
+            // already threw if channelConfig is missing when --cwd is used.
             const cwdResult = await resolveSessionWorkingDirectory({
                 projectDirectory: projectDirectory,
                 candidatePath: options.cwd,
@@ -510,8 +534,8 @@ cli
             process.stdout.write(`Session: ${newSessionId}\n`);
         process.stdout.write(`${threadUrl}\n`);
         if (options.wait) {
-            // projectDirectory is guaranteed here: --wait is incompatible with --notify-only,
-            // and non-notify sends already require channelConfig above.
+            // projectDirectory is guaranteed here: needsProjectDirectory check above
+            // already threw if channelConfig is missing when --wait is used.
             const { waitAndOutputSession } = await import('../wait-session.js');
             await waitAndOutputSession({
                 threadId: threadData.id,

package/dist/cli-commands/session.js

@@ -126,6 +126,7 @@ cli
 cli
     .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
     .option('--project <path>', 'Project directory (defaults to cwd)')
+    .option('--verbose', 'Show full tool inputs and outputs instead of compact summaries')
     .action(async (sessionId, options) => {
     try {
         const projectDirectory = path.resolve(options.project || '.');
@@ -137,8 +138,9 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         // Try current project first (fast path)
+        const compactTools = !options.verbose;
         const markdown = new ShareMarkdown(getClient());
-        const result = await markdown.generate({ sessionID: sessionId });
+        const result = await markdown.generate({ sessionID: sessionId, compactTools });
         if (!(result instanceof Error)) {
             process.stdout.write(result);
             process.exit(0);
@@ -171,6 +173,7 @@ cli
             const otherMarkdown = new ShareMarkdown(otherClient());
             const otherResult = await otherMarkdown.generate({
                 sessionID: sessionId,
+                compactTools,
             });
             if (!(otherResult instanceof Error)) {
                 process.stdout.write(otherResult);

package/dist/commands/agent.js

@@ -4,12 +4,16 @@
 // the prompt is sent with that agent and the session keeps that agent afterwards.
 import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, MessageFlags, } from 'discord.js';
 import crypto from 'node:crypto';
-import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, } from '../database.js';
+import { setChannelAgent, setSessionAgent, clearSessionModel, getThreadSession, getSessionAgent, getChannelAgent, getChannelWorktreesEnabled, } from '../database.js';
 import { initializeOpencodeForDirectory } from '../opencode.js';
 import { resolveTextChannel, resolveWorkingDirectory, getKimakiMetadata, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
 import { getOrCreateRuntime } from '../session-handler/thread-session-runtime.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { getCurrentModelInfo } from './model.js';
+import { isGitRepositoryRoot } from '../worktrees.js';
+import { formatAutoWorktreeName, createWorktreeInBackground, worktreeCreatingMessage, } from './new-worktree.js';
+import { WORKTREE_PREFIX } from './merge-worktree.js';
+import { store } from '../store.js';
 const agentLogger = createLogger(LogPrefix.AGENT);
 const AGENT_CONTEXT_TTL_MS = 10 * 60 * 1000;
 const pendingAgentContexts = new Map();
@@ -429,22 +433,65 @@ async function handleQuickAgentWithPrompt({ command, appId, fallbackAgentName, p
             return;
         }
         await command.deferReply();
+        // Check if worktrees should be enabled (CLI flag OR channel setting),
+        // mirroring the logic in discord-bot.ts message handler.
+        const wantsWorktrees = store.getState().useWorktrees ||
+            (await getChannelWorktreesEnabled(channel.id));
+        const shouldUseWorktrees = wantsWorktrees && (await isGitRepositoryRoot(projectDirectory));
+        if (wantsWorktrees && !shouldUseWorktrees) {
+            agentLogger.warn(`[WORKTREE] Skipping automatic worktree for non-git project directory: ${projectDirectory}`);
+        }
+        const baseThreadName = prompt.slice(0, 80);
+        const threadName = shouldUseWorktrees
+            ? `${WORKTREE_PREFIX}${baseThreadName}`
+            : baseThreadName;
         const starterMessage = await channel.send({
             content: `» **${command.user.displayName}** (${resolvedAgentName}): ${displayText}`,
             flags: SILENT_MESSAGE_FLAGS,
         });
         const thread = await starterMessage.startThread({
-            name: prompt.slice(0, 80),
+            name: threadName.slice(0, 80),
             autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
             reason: `${resolvedAgentName} agent prompt`,
         });
         await thread.members.add(command.user.id);
-        await command.editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`);
+        // Create worktree in background if enabled, same as discord-bot.ts
+        let worktreePromise;
+        if (shouldUseWorktrees) {
+            const worktreeName = formatAutoWorktreeName(baseThreadName.slice(0, 50));
+            agentLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
+            const worktreeStatusMessage = await thread
+                .send({
+                content: worktreeCreatingMessage(worktreeName),
+                flags: SILENT_MESSAGE_FLAGS,
+            })
+                .catch(() => undefined);
+            worktreePromise = createWorktreeInBackground({
+                thread,
+                starterMessage: worktreeStatusMessage,
+                worktreeName,
+                projectDirectory,
+                rest: command.client.rest,
+            });
+        }
+        const sessionDirectory = await (async () => {
+            if (!worktreePromise)
+                return projectDirectory;
+            const result = await worktreePromise;
+            if (result instanceof Error)
+                return projectDirectory;
+            return result;
+        })();
+        await command
+            .editReply(`Sent with **${resolvedAgentName}** agent in ${thread.toString()}`)
+            .catch(() => {
+            agentLogger.warn('[AGENT] Failed to edit quick-agent reply, continuing session');
+        });
         const runtime = getOrCreateRuntime({
             threadId: thread.id,
             thread,
             projectDirectory,
-            sdkDirectory: projectDirectory,
+            sdkDirectory: sessionDirectory,
             channelId: channel.id,
             appId,
         });

package/dist/discord-bot.js

@@ -173,6 +173,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
     if (!discordClient) {
         discordClient = await createDiscordClient();
     }
+    store.setState({ useWorktrees: Boolean(useWorktrees) });
     let currentAppId = appId;
     const setupHandlers = async (c) => {
         discordLogger.log(`Discord bot logged in as ${c.user.tag}`);
@@ -332,15 +333,13 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     return;
                 }
             }
-            // Ignore messages that start with a mention of another user (not the bot).
-            // These are likely users talking to each other, not the bot.
+            // Detect messages that start with a mention of another user (not the bot).
+            // In channels these are fully ignored. In threads they are added to the
+            // session context without triggering the AI (noReply), so the agent sees
+            // user-to-user conversation on the next real turn.
             const leadingMentionMatch = message.content?.match(/^<@!?(\d+)>/);
-            if (leadingMentionMatch) {
-                const mentionedUserId = leadingMentionMatch[1];
-                if (mentionedUserId !== discordClient.user?.id) {
-                    return;
-                }
-            }
+            const isLeadingMentionToOtherUser = leadingMentionMatch &&
+                leadingMentionMatch[1] !== discordClient.user?.id;
             if (message.partial) {
                 discordLogger.log(`Fetching partial message ${message.id}`);
                 const fetched = await message.fetch()
@@ -354,6 +353,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             // When mention mode is enabled, users without Kimaki role can message
             // without getting a permission error - we just silently ignore.
             const channel = message.channel;
+            // In text channels, messages starting with a mention to another user
+            // are fully ignored before any permission or mention-mode checks.
+            // This prevents permission-error replies for user-to-user conversation.
+            if (channel.type === ChannelType.GuildText && isLeadingMentionToOtherUser) {
+                return;
+            }
             if (channel.type === ChannelType.GuildText && !isCliInjectedPrompt) {
                 const mentionModeEnabled = await getChannelMentionMode(channel.id);
                 if (mentionModeEnabled) {
@@ -435,6 +440,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     discordLogger.log(`Ignoring thread ${thread.id}: no existing session and bot not mentioned`);
                     return;
                 }
+                // Context-only messages (user-to-user replies) can't be stored without
+                // an existing session. Skip early to avoid creating a runtime or running
+                // preprocessing for nothing.
+                if (isLeadingMentionToOtherUser && !hasExistingSession) {
+                    return;
+                }
                 const parent = thread.parent;
                 let projectDirectory;
                 if (parent) {
@@ -509,7 +520,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 const btwResult = projectDirectory && worktreeInfo?.status !== 'pending'
                     ? extractBtwSuffix(message.content || '')
                     : null;
-                if (btwResult?.forceBtw && projectDirectory) {
+                if (btwResult?.forceBtw && projectDirectory && !isLeadingMentionToOtherUser) {
                     const result = await forkSessionToBtwThread({
                         sourceThread: thread,
                         projectDirectory,
@@ -559,7 +570,9 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     appId: currentAppId,
                 });
                 // Cancel interactive UI when a real user sends a message.
-                if (!message.author.bot && !isCliInjectedPrompt) {
+                // Context-only messages (user-to-user replies) should not interrupt
+                // the active run or dismiss pending UI.
+                if (!message.author.bot && !isCliInjectedPrompt && !isLeadingMentionToOtherUser) {
                     cancelPendingActionButtons(thread.id);
                     cancelHtmlActionsForThread(thread.id);
                     const dismissedPermission = await cancelPendingPermission(thread.id);
@@ -594,6 +607,7 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     model: cliInjectedModel,
                     permissions: cliInjectedPermissions,
                     injectionGuardPatterns: cliInjectedInjectionGuardPatterns,
+                    noReply: isLeadingMentionToOtherUser || undefined,
                     sessionStartSource: sessionStartSource
                         ? {
                             scheduleKind: sessionStartSource.scheduleKind,

package/dist/markdown.js

@@ -26,7 +26,7 @@ export class ShareMarkdown {
      * @returns Error or markdown string
      */
     async generate(options) {
-        const { sessionID, includeSystemInfo, lastAssistantOnly } = options;
+        const { sessionID, includeSystemInfo, lastAssistantOnly, compactTools = true } = options;
         // Get session info
         const sessionResponse = await this.client.session.get({
             sessionID,
@@ -75,13 +75,13 @@ export class ShareMarkdown {
             lines.push('');
         }
         for (const message of messagesToRender) {
-            const messageLines = this.renderMessage(message.info, message.parts);
+            const messageLines = this.renderMessage(message.info, message.parts, { compactTools });
             lines.push(...messageLines);
             lines.push('');
         }
         return lines.join('\n');
     }
-    renderMessage(message, parts) {
+    renderMessage(message, parts, opts) {
         const lines = [];
         if (message.role === 'user') {
             lines.push('### 👤 User');
@@ -128,7 +128,9 @@ export class ShareMarkdown {
                 return true;
             });
             for (const part of filteredParts) {
-                const partLines = this.renderPart(part, message);
+                const partLines = opts.compactTools
+                    ? this.renderPartCompact(part, message)
+                    : this.renderPart(part, message);
                 lines.push(...partLines);
             }
             // Add completion time if available
@@ -214,6 +216,59 @@ export class ShareMarkdown {
         }
         return lines;
     }
+    /** Compact rendering: tool calls become a single line with line count instead of full output. */
+    renderPartCompact(part, message) {
+        // Non-tool parts render the same as verbose
+        if (part.type !== 'tool') {
+            return this.renderPart(part, message);
+        }
+        const lines = [];
+        if (part.state.status === 'completed') {
+            const output = part.state.output || '';
+            const lineCount = output ? output.split('\n').length : 0;
+            const inputSummary = this.compactInputSummary(part.state.input);
+            const outputLabel = lineCount > 0 ? `(${lineCount} lines)` : '';
+            const parts = [inputSummary, outputLabel].filter(Boolean).join(' ');
+            lines.push(`> 🛠️ **${part.tool}**${parts ? ` ${parts}` : ''}`);
+            lines.push('');
+        }
+        else if (part.state.status === 'error') {
+            const errorText = (part.state.error || 'Unknown error').split('\n')[0].slice(0, 120);
+            lines.push(`> ❌ **${part.tool}** — ${errorText}`);
+            lines.push('');
+        }
+        return lines;
+    }
+    /** Build a compact key=value summary of tool input, max 2 params, 80 chars each. */
+    compactInputSummary(input) {
+        if (!input)
+            return '';
+        const entries = Object.entries(input);
+        if (entries.length === 0)
+            return '';
+        const parts = [];
+        const maxParams = 2;
+        for (let i = 0; i < Math.min(entries.length, maxParams); i++) {
+            const [key, value] = entries[i];
+            let val;
+            try {
+                val = typeof value === 'string'
+                    ? value
+                    : (JSON.stringify(value) ?? String(value));
+            }
+            catch {
+                val = String(value);
+            }
+            // Collapse whitespace for readability
+            const collapsed = val.replace(/\s+/g, ' ').trim();
+            const normalized = collapsed.length > 80 ? `${collapsed.slice(0, 80)}…` : collapsed;
+            parts.push(`${key}=${normalized}`);
+        }
+        if (entries.length > maxParams) {
+            parts.push('...');
+        }
+        return parts.join(', ');
+    }
     formatDuration(ms) {
         if (ms < 1000)
             return `${ms}ms`;