kimaki 0.25.0 → 0.26.0

package/dist/agent-model.e2e.test.js

@@ -189,7 +189,7 @@ function createAgentFile({ projectDirectory, agentName, model, }) {
     fs.mkdirSync(agentDir, { recursive: true });
     const content = [
         '---',
-        `model: ${model}`,
+        ...(model ? [`model: ${model}`] : []),
         'mode: primary',
         `description: Test agent with custom model`,
         '---',
@@ -289,6 +289,10 @@ describe('agent model resolution', () => {
             agentName: 'plan',
             model: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
         });
+        createAgentFile({
+            projectDirectory: directories.projectDirectory,
+            agentName: 'plain',
+        });
         const dbPath = path.join(directories.dataDir, 'discord-sessions.db');
         const hranaResult = await startHranaServer({ dbPath });
         if (hranaResult instanceof Error) {
@@ -311,7 +315,7 @@ describe('agent model resolution', () => {
         });
         // Register quick agent slash commands so /plan-agent and /test-agent-agent
         // are resolvable by handleQuickAgentCommand via guild.commands.fetch().
-        const agentCommands = ['test-agent', 'plan'].map((agentName) => {
+        const agentCommands = ['test-agent', 'plan', 'plain'].map((agentName) => {
             return new SlashCommandBuilder()
                 .setName(`${agentName}-agent`)
                 .setDescription(buildQuickAgentCommandDescription({
@@ -976,7 +980,7 @@ describe('agent model resolution', () => {
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
-        Model: *deterministic-provider/plan-model-v2*
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg
@@ -994,4 +998,132 @@ describe('agent model resolution', () => {
         expect(secondFooter.content).toContain(PLAN_AGENT_MODEL);
         expect(secondFooter.content).not.toContain(AGENT_MODEL);
     }, 20_000);
+    test('/plan-agent on the same agent refreshes a stale session model', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'plan');
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: refresh-agent-model-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: refresh-agent-model-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeDefined();
+        if (!sessionId)
+            throw new Error('Expected session');
+        await setSessionModel({
+            sessionId,
+            modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+        });
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: refresh-agent-model-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/plan-model-v2 ⋅ plan*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***
+        Using **plan** agent for this session
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
+        The agent will change on the next message."
+      `);
+        expect(await th.text()).not.toContain('Already using');
+        expect(await getSessionModel(sessionId)).toBeUndefined();
+    }, 20_000);
+    test('/plan-agent shows the agent model when a channel model is also set', async () => {
+        await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent');
+        await setChannelModel({
+            channelId: TEXT_CHANNEL_ID,
+            modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+        });
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: channel-vs-agent-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: channel-vs-agent-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plan-agent' });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        const threadText = await th.text();
+        expect(threadText).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: channel-vs-agent-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        Switched to **plan** agent for this session (was **test-agent**)
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
+        The agent will change on the next message."
+      `);
+        expect(threadText).toContain(`Model: *${PROVIDER_NAME}/${PLAN_AGENT_MODEL}* (agent "plan")`);
+        expect(threadText).not.toContain('channel override');
+    }, 20_000);
+    test('/plain-agent tells the user to clear a channel model override', async () => {
+        const db = await getDb();
+        await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID));
+        await setChannelModel({
+            channelId: TEXT_CHANNEL_ID,
+            modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+        });
+        await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: plain-agent-override-msg',
+        });
+        const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: plain-agent-override-msg';
+            },
+        });
+        await waitForFooterMessage({
+            discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: discord.botUserId,
+        });
+        const th = discord.thread(thread.id);
+        const { id: interactionId } = await th
+            .user(TEST_USER_ID)
+            .runSlashCommand({ name: 'plain-agent' });
+        await th.waitForInteractionAck({ interactionId, timeout: 4_000 });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: plain-agent-override-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/channel-model-v2*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*
+        Switched to **plain** agent for this session
+        Model: *deterministic-provider/channel-model-v2* (channel override)
+        This model comes from a channel override. Use /model and press Clear override if you want this agent's model.
+        The agent will change on the next message."
+      `);
+    }, 20_000);
 });

package/dist/analytics.test.js

@@ -90,7 +90,7 @@ describe('analytics', () => {
             bot_mode: 'gateway',
         });
     });
-    it('emits project_registered session_created turn_completed shapes', () => {
+    it('emits project_registered session_created turn_completed tokens_used shapes', () => {
         const captured = _enableAnalyticsTestCapture({
             installId: '33333333-3333-4333-8333-333333333333',
             botMode: 'self_hosted',
@@ -107,10 +107,24 @@ describe('analytics', () => {
         trackEvent('turn_completed', {
             duration_sec: 42,
         });
+        trackEvent('tokens_used', {
+            tokens_input: 100,
+            tokens_output: 20,
+            tokens_reasoning: 5,
+            tokens_cache_read: 10,
+            tokens_cache_write: 2,
+            tokens_total: 137,
+            cost: 0,
+            assistant_message_count: 2,
+            is_subagent: false,
+            model: 'gpt-5.3-codex',
+            provider: 'openai',
+        });
         expect(captured.map((e) => e.name)).toEqual([
             'project_registered',
             'session_created',
             'turn_completed',
+            'tokens_used',
         ]);
         expect(captured[0].properties).toMatchObject({
             project_kind: 'user',
@@ -126,5 +140,20 @@ describe('analytics', () => {
         expect(captured[2].properties).toMatchObject({
             duration_sec: 42,
         });
+        expect(captured[3].properties).toMatchObject({
+            tokens_input: 100,
+            tokens_output: 20,
+            tokens_reasoning: 5,
+            tokens_cache_read: 10,
+            tokens_cache_write: 2,
+            tokens_total: 137,
+            cost: 0,
+            assistant_message_count: 2,
+            is_subagent: false,
+            model: 'gpt-5.3-codex',
+            provider: 'openai',
+            install_id: '33333333-3333-4333-8333-333333333333',
+            schema_version: 1,
+        });
     });
 });

package/dist/cli-commands/send.js

@@ -52,6 +52,8 @@ cli
     .option('-f, --file <path>', z.array(z.string()).describe('Local file to attach (repeatable). Images, text files, PDFs, etc. ' +
     'Examples: --file screenshot.png --file report.pdf'))
     .option('--send-at <schedule>', 'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)')
+    .option('--pre-run <command>', 'Run a shell command in the project before starting a scheduled task')
+    .option('--allow-concurrency', 'Allow concurrent sessions from the same scheduled task')
     .option('--thread <threadId>', 'Post prompt to an existing thread')
     .option('--session <sessionId>', 'Post prompt to thread mapped to an existing session')
     .option('--parent-session <sessionId>', 'Parent OpenCode session ID for newly created child sessions')
@@ -67,6 +69,10 @@ cli
         const { project: projectPath } = options;
         const sendAt = options.sendAt;
         const existingThreadMode = Boolean(threadId || sessionId);
+        if ((options.preRun || options.allowConcurrency) && !sendAt) {
+            cliLogger.error('--pre-run and --allow-concurrency require --send-at');
+            process.exit(EXIT_NO_RESTART);
+        }
         if (threadId && sessionId) {
             cliLogger.error('Use either --thread or --session, not both');
             process.exit(EXIT_NO_RESTART);
@@ -348,6 +354,8 @@ cli
                     permissions: options.permission?.length ? options.permission : null,
                     injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
                     parentSessionId: options.parentSession || null,
+                    preRunCommand: options.preRun || null,
+                    allowConcurrency: Boolean(options.allowConcurrency),
                 };
                 const taskId = await createScheduledTask({
                     scheduleKind: parsedSchedule.scheduleKind,
@@ -387,7 +395,7 @@ cli
             // detection can find the command on its own line.
             const prefixedPrompt = `» **kimaki-cli:**\n${prompt}`;
             if (threadTargetUser) {
-                cliLogger.log(`Adding user ${threadTargetUser.username} to thread...`);
+                cliLogger.log(`Adding user ${threadTargetUser.username || threadTargetUser.id} to thread...`);
                 const addMemberResult = await ensureThreadMember({
                     rest,
                     threadId: targetThreadId,
@@ -509,6 +517,8 @@ cli
                 permissions: options.permission?.length ? options.permission : null,
                 injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
                 parentSessionId: options.parentSession || null,
+                preRunCommand: options.preRun || null,
+                allowConcurrency: Boolean(options.allowConcurrency),
             };
             const taskId = await createScheduledTask({
                 scheduleKind: parsedSchedule.scheduleKind,
@@ -535,8 +545,8 @@ cli
                 ...(worktreeName && { worktree: worktreeName }),
                 ...(resolvedCwd && { cwd: resolvedCwd }),
                 ...(resolvedUser && {
-                    username: resolvedUser.username,
                     userId: resolvedUser.id,
+                    ...(resolvedUser.username && { username: resolvedUser.username }),
                 }),
                 ...(options.agent && { agent: options.agent }),
                 ...(options.model && { model: options.model }),
@@ -574,7 +584,7 @@ cli
         cliLogger.log('Thread created!');
         // Add user to thread if specified
         if (resolvedUser) {
-            cliLogger.log(`Adding user ${resolvedUser.username} to thread...`);
+            cliLogger.log(`Adding user ${resolvedUser.username || resolvedUser.id} to thread...`);
             await rest.put(Routes.threadMembers(threadData.id, resolvedUser.id));
         }
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;

package/dist/cli-commands/task.js

@@ -40,7 +40,7 @@ cli
             cliLogger.log('No scheduled tasks found');
             process.exit(0);
         }
-        console.log('id | status | message | channelId | userId | projectName | folderName | agent | model | timeRemaining | firesAt | cron');
+        console.log('id | status | message | channelId | userId | projectName | folderName | agent | model | preRun | allowConcurrency | timeRemaining | firesAt | cron');
         tasks.forEach((task) => {
             // Surfacing userId makes it obvious which tasks will never show up in
             // the user's Discord sidebar (no thread member is ever added for them).
@@ -49,6 +49,10 @@ cli
             const userId = payload instanceof Error ? '?' : payload.userId || '-';
             const agent = payload instanceof Error ? '?' : payload.agent || '-';
             const model = payload instanceof Error ? '?' : payload.model || '-';
+            const preRun = payload instanceof Error ? '?' : payload.preRunCommand || '-';
+            const allowConcurrency = payload instanceof Error
+                ? '?'
+                : String(payload.allowConcurrency);
             const projectDirectory = task.project_directory || '';
             const projectName = projectDirectory
                 ? path.basename(projectDirectory)
@@ -60,7 +64,7 @@ cli
                 ? task.run_at.toISOString()
                 : '-';
             const cronValue = task.schedule_kind === 'cron' ? task.cron_expr || '-' : '-';
-            console.log(`${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${userId} | ${projectName} | ${folderName} | ${agent} | ${model} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`);
+            console.log(`${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${userId} | ${projectName} | ${folderName} | ${agent} | ${model} | ${preRun} | ${allowConcurrency} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`);
         });
         process.exit(0);
     }
@@ -98,7 +102,7 @@ cli
 async function resolveTaskUser({ user, channelId, }) {
     const directUserId = getDiscordUserIdFromUserOption(user);
     if (directUserId) {
-        return { id: directUserId, username: directUserId };
+        return { id: directUserId };
     }
     if (!channelId) {
         return new Error(`Cannot look up username "${user}": task has no channel to resolve a guild from. Pass a Discord user ID instead.`);
@@ -128,18 +132,24 @@ cli
     .option('--send-at <sendAt>', 'New schedule (UTC ISO date or cron expression)')
     .option('--agent <agent>', 'Agent for the scheduled session (empty string clears)')
     .option('--model <model>', 'Model for the scheduled session, format provider/model (empty string clears)')
+    .option('--pre-run <command>', 'New pre-run command (empty string clears)')
+    .option('--allow-concurrency <enabled>', z.enum(['true', 'false']).describe('Allow concurrent sessions: true or false'))
     .option('-u, --user <user>', 'Discord user ID, mention, or username added to the task thread')
     .action(async (id, options) => {
     try {
         const trimmedPrompt = options.prompt === undefined ? undefined : options.prompt.trim();
         const hasAgent = options.agent !== undefined;
         const hasModel = options.model !== undefined;
+        const hasPreRun = options.preRun !== undefined;
+        const hasAllowConcurrency = options.allowConcurrency !== undefined;
         if (!trimmedPrompt &&
             !options.sendAt &&
             !options.user &&
             !hasAgent &&
-            !hasModel) {
-            cliLogger.error('Provide at least --prompt, --send-at, --user, --agent or --model');
+            !hasModel &&
+            !hasPreRun &&
+            !hasAllowConcurrency) {
+            cliLogger.error('Provide at least --prompt, --send-at, --user, --agent, --model, --pre-run or --allow-concurrency');
             process.exit(EXIT_NO_RESTART);
         }
         if (trimmedPrompt !== undefined && trimmedPrompt.length === 0) {
@@ -186,10 +196,14 @@ cli
             ...existingPayload,
             prompt: newPrompt,
             ...(resolvedUser
-                ? { userId: resolvedUser.id, username: resolvedUser.username }
+                ? { userId: resolvedUser.id, username: resolvedUser.username || null }
                 : {}),
             ...(hasAgent ? { agent: options.agent.trim() || null } : {}),
             ...(hasModel ? { model: options.model.trim() || null } : {}),
+            ...(hasPreRun ? { preRunCommand: options.preRun.trim() || null } : {}),
+            ...(hasAllowConcurrency
+                ? { allowConcurrency: options.allowConcurrency === 'true' }
+                : {}),
         };
         const updateData = {
             taskId,
@@ -220,7 +234,7 @@ cli
         }
         const parts = [`Updated task ${taskId}`];
         if (resolvedUser) {
-            parts.push(`user ${resolvedUser.username} will be added to the thread`);
+            parts.push(`user ${resolvedUser.username || resolvedUser.id} will be added to the thread`);
         }
         if (hasAgent) {
             parts.push(`agent=${updatedPayload.agent || '-'}`);
@@ -228,6 +242,11 @@ cli
         if (hasModel) {
             parts.push(`model=${updatedPayload.model || '-'}`);
         }
+        if (hasPreRun)
+            parts.push(`preRun=${updatedPayload.preRunCommand || '-'}`);
+        if (hasAllowConcurrency) {
+            parts.push(`allowConcurrency=${updatedPayload.allowConcurrency}`);
+        }
         cliLogger.log(parts.join(' | '));
         process.exit(0);
     }

package/dist/cli-runner.js

@@ -12,7 +12,6 @@ import { discordApiUrl, getDiscordRestApiUrl, getGatewayProxyRestBaseUrl, getInt
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs';
-import os from 'node:os';
 import { spawn } from 'node:child_process';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
@@ -130,6 +129,42 @@ export async function resolveBotCredentials({ appIdOverride } = {}) {
     process.exit(EXIT_NO_RESTART);
 }
 export { isThreadChannelType };
+/** Wrap long lines so prompt.md is readable in Discord's attachment preview. */
+function wrapPromptAttachmentText(prompt) {
+    return prompt
+        .split('\n')
+        .flatMap((line) => {
+        if (line.length <= 120) {
+            return [line];
+        }
+        const wrapped = [];
+        let remaining = line;
+        const maxCol = 120;
+        // Only soft-break at a space if it's reasonably close to maxCol,
+        // otherwise hard-break to avoid tiny fragments from early spaces
+        const minSoftBreak = 90;
+        while (remaining.length > maxCol) {
+            const lastSpace = remaining.lastIndexOf(' ', maxCol);
+            const useSoftBreak = lastSpace >= minSoftBreak;
+            const breakAt = useSoftBreak ? lastSpace : maxCol;
+            wrapped.push(remaining.slice(0, breakAt));
+            // Only consume the separator space on soft breaks
+            remaining = useSoftBreak
+                ? remaining.slice(breakAt + 1)
+                : remaining.slice(breakAt);
+        }
+        if (remaining.length > 0) {
+            wrapped.push(remaining);
+        }
+        return wrapped;
+    })
+        .join('\n');
+}
+function promptAttachmentBlob(text) {
+    return new Blob([new Uint8Array(Buffer.from(text, 'utf8'))], {
+        type: 'text/markdown',
+    });
+}
 export async function sendDiscordMessageWithOptionalAttachment({ channelId, prompt, botToken, embeds, rest, splitInsteadOfAttach, files, }) {
     const discordMaxLength = 2000;
     // When files are provided, always use multipart FormData upload
@@ -145,22 +180,23 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
             }
         }
         // When prompt exceeds Discord's limit, attach it as prompt.md alongside
-        // user files so nothing is silently lost.
+        // user files so nothing is silently lost. Build prompt.md from memory so
+        // parallel kimaki send processes never share or unlink a temp path.
         const isLongPrompt = prompt.length > discordMaxLength;
         const content = isLongPrompt
             ? `Prompt attached as file (${prompt.length} chars)\n\n> ${prompt.slice(0, 100).replace(/\n/g, ' ')}...`
             : prompt;
-        // Build attachment metadata: user files + optional prompt.md
         const allFiles = files.map((file) => ({
-            filePath: file,
+            data: new Uint8Array(fs.readFileSync(file)),
             filename: path.basename(file),
             mimeType: mime.getType(file) || 'application/octet-stream',
         }));
         if (isLongPrompt) {
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'));
-            const tmpFile = path.join(tmpDir, 'prompt.md');
-            fs.writeFileSync(tmpFile, prompt);
-            allFiles.push({ filePath: tmpFile, filename: 'prompt.md', mimeType: 'text/markdown' });
+            allFiles.push({
+                data: new Uint8Array(Buffer.from(prompt, 'utf8')),
+                filename: 'prompt.md',
+                mimeType: 'text/markdown',
+            });
         }
         const attachments = allFiles.map((f, index) => ({
             id: index,
@@ -174,8 +210,7 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
             allowed_mentions: { parse: store.getState().allowedMentions },
         }));
         for (const [index, f] of allFiles.entries()) {
-            const buffer = fs.readFileSync(f.filePath);
-            formData.append(`files[${index}]`, new Blob([buffer], { type: f.mimeType }), f.filename);
+            formData.append(`files[${index}]`, new Blob([f.data], { type: f.mimeType }), f.filename);
         }
         const response = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
             method: 'POST',
@@ -226,66 +261,27 @@ export async function sendDiscordMessageWithOptionalAttachment({ channelId, prom
     }
     const preview = prompt.slice(0, 100).replace(/\n/g, ' ');
     const summaryContent = `Prompt attached as file (${prompt.length} chars)\n\n> ${preview}...`;
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-prompt-'));
-    const tmpFile = path.join(tmpDir, 'prompt.md');
-    // Wrap long lines so the file is readable in Discord's preview
-    // (Discord doesn't wrap text in file attachments)
-    const wrappedPrompt = prompt
-        .split('\n')
-        .flatMap((line) => {
-        if (line.length <= 120) {
-            return [line];
-        }
-        const wrapped = [];
-        let remaining = line;
-        const maxCol = 120;
-        // Only soft-break at a space if it's reasonably close to maxCol,
-        // otherwise hard-break to avoid tiny fragments from early spaces
-        const minSoftBreak = 90;
-        while (remaining.length > maxCol) {
-            const lastSpace = remaining.lastIndexOf(' ', maxCol);
-            const useSoftBreak = lastSpace >= minSoftBreak;
-            const breakAt = useSoftBreak ? lastSpace : maxCol;
-            wrapped.push(remaining.slice(0, breakAt));
-            // Only consume the separator space on soft breaks
-            remaining = useSoftBreak
-                ? remaining.slice(breakAt + 1)
-                : remaining.slice(breakAt);
-        }
-        if (remaining.length > 0) {
-            wrapped.push(remaining);
-        }
-        return wrapped;
-    })
-        .join('\n');
-    fs.writeFileSync(tmpFile, wrappedPrompt);
-    try {
-        const formData = new FormData();
-        formData.append('payload_json', JSON.stringify({
-            content: summaryContent,
-            attachments: [{ id: 0, filename: 'prompt.md' }],
-            embeds,
-            allowed_mentions: { parse: store.getState().allowedMentions },
-        }));
-        const buffer = fs.readFileSync(tmpFile);
-        formData.append('files[0]', new Blob([buffer], { type: 'text/markdown' }), 'prompt.md');
-        const starterMessageResponse = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
-            method: 'POST',
-            headers: {
-                Authorization: `Bot ${botToken}`,
-            },
-            body: formData,
-        });
-        if (!starterMessageResponse.ok) {
-            const error = await starterMessageResponse.text();
-            throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`);
-        }
-        return (await starterMessageResponse.json());
-    }
-    finally {
-        fs.unlinkSync(tmpFile);
-        fs.rmdirSync(tmpDir);
+    // In-memory Blob only — no temp file. Parallel send must never share a path.
+    const formData = new FormData();
+    formData.append('payload_json', JSON.stringify({
+        content: summaryContent,
+        attachments: [{ id: 0, filename: 'prompt.md' }],
+        embeds,
+        allowed_mentions: { parse: store.getState().allowedMentions },
+    }));
+    formData.append('files[0]', promptAttachmentBlob(wrapPromptAttachmentText(prompt)), 'prompt.md');
+    const starterMessageResponse = await fetch(discordApiUrl(`/channels/${channelId}/messages`), {
+        method: 'POST',
+        headers: {
+            Authorization: `Bot ${botToken}`,
+        },
+        body: formData,
+    });
+    if (!starterMessageResponse.ok) {
+        const error = await starterMessageResponse.text();
+        throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`);
     }
+    return (await starterMessageResponse.json());
 }
 export function formatRelativeTime(target) {
     const diffMs = target.getTime() - Date.now();
@@ -435,7 +431,7 @@ export async function resolveDiscordUserOption({ user, guildId, rest, }) {
     const directUserId = getDiscordUserIdFromUserOption(user);
     if (directUserId) {
         cliLogger.log(`Using Discord user ID: ${directUserId}`);
-        return { id: directUserId, username: directUserId };
+        return { id: directUserId };
     }
     cliLogger.log(`Searching for user "${user}" in guild...`);
     const searchResult = await rest

package/dist/cli-runner.test.js

@@ -1,5 +1,14 @@
 import { describe, expect, test } from 'vitest';
-import { getOpenUrlCommand, isTransientNetworkError } from './cli-runner.js';
+import { REST } from 'discord.js';
+import { getOpenUrlCommand, isTransientNetworkError, resolveDiscordUserOption, } from './cli-runner.js';
+test('raw Discord user ID does not invent a username', async () => {
+    const user = await resolveDiscordUserOption({
+        user: '535922349652836367',
+        guildId: '1422625037164351591',
+        rest: new REST(),
+    });
+    expect(user).toEqual({ id: '535922349652836367' });
+});
 describe('getOpenUrlCommand', () => {
     const installUrl = 'https://kimaki.dev/discord-install?clientId=abc&clientSecret=def';
     test('uses a shell-free opener on Windows', () => {