kimaki 0.4.90 → 0.4.91

package/dist/commands/merge-worktree.js

@@ -1,6 +1,7 @@
 // /merge-worktree command - Merge worktree commits into default branch.
-// Uses worktrunk-style pipeline: squash -> rebase -> local push.
-// On rebase conflicts, asks the AI model in the thread to resolve them.
+// Pipeline: rebase worktree commits onto target -> local fast-forward push.
+// Preserves all commits (no squash). On rebase conflicts, asks the AI model
+// in the thread to resolve them.
 import {} from 'discord.js';
 import { getThreadWorktree, getThreadSession, getChannelDirectory, } from '../database.js';
 import { createLogger, LogPrefix } from '../logger.js';
@@ -103,12 +104,14 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             await sendPromptToModel({
                 prompt: [
                     'A rebase conflict occurred while merging this worktree into the default branch.',
+                    'Rebasing multiple commits can pause on each commit that conflicts, so you may need to repeat the resolve/continue loop several times.',
                     'Please resolve the rebase conflicts:',
                     '1. Check `git status` to see which files have conflicts',
                     '2. Edit the conflicted files to resolve the merge markers',
                     '3. Stage resolved files with `git add`',
                     '4. Continue the rebase with `git rebase --continue`',
-                    '5. After the rebase completes successfully, tell me so I can run `/merge-worktree` again',
+                    '5. If git reports more conflicts, repeat steps 1-4 until the rebase finishes (no more MERGE markers, `git status` shows no rebase in progress)',
+                    '6. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
                 ].join('\n'),
                 thread,
                 projectDirectory: worktreeInfo.project_directory,

package/dist/commands/new-worktree.js

@@ -89,18 +89,30 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
                 worktreeName,
                 projectDirectory,
             });
+            // Serialize status message edits so onProgress can't overwrite the
+            // final success/error edit even if Discord's API is slow.
+            let editChain = Promise.resolve();
+            const editStatus = (content) => {
+                editChain = editChain
+                    .then(async () => {
+                    await starterMessage?.edit(content);
+                })
+                    .catch(() => { });
+            };
             const worktreeResult = await createWorktreeWithSubmodules({
                 directory: projectDirectory,
                 name: worktreeName,
                 baseBranch,
+                onProgress: (phase) => {
+                    editStatus(`🌳 **Worktree: ${worktreeName}**\n${phase}`);
+                },
             });
             if (worktreeResult instanceof Error) {
                 const errorMsg = worktreeResult.message;
                 logger.error('[WORKTREE] Creation failed:', worktreeResult);
                 await setWorktreeError({ threadId: thread.id, errorMessage: errorMsg });
-                await starterMessage
-                    ?.edit(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`)
-                    .catch(() => { });
+                editStatus(`🌳 **Worktree: ${worktreeName}**\n❌ ${errorMsg}`);
+                await editChain;
                 return worktreeResult;
             }
             // Success - update database and edit starter message
@@ -115,11 +127,10 @@ export async function createWorktreeInBackground({ thread, starterMessage, workt
                 channelId: thread.parentId || undefined,
                 emoji: '🌳',
             });
-            await starterMessage
-                ?.edit(`🌳 **Worktree: ${worktreeName}**\n` +
+            editStatus(`🌳 **Worktree: ${worktreeName}**\n` +
                 `📁 \`${worktreeResult.directory}\`\n` +
-                `🌿 Branch: \`${worktreeResult.branch}\``)
-                .catch(() => { });
+                `🌿 Branch: \`${worktreeResult.branch}\``);
+            await editChain;
             return worktreeResult.directory;
         },
         catch: (e) => {

package/dist/commands/worktrees.js

@@ -1,13 +1,14 @@
-// /worktrees command — list all worktree sessions sorted by creation date.
+// /worktrees command — list worktree sessions for the current channel's project.
 // Renders a markdown table that the CV2 pipeline auto-formats for Discord,
 // including HTML-backed action buttons for deletable worktrees.
-import { ButtonInteraction, ChatInputCommandInteraction, ComponentType, MessageFlags, } from 'discord.js';
+import { ButtonInteraction, ChatInputCommandInteraction, ChannelType, ComponentType, MessageFlags, } from 'discord.js';
 import { deleteThreadWorktree, getThreadWorktree, } from '../database.js';
 import { getPrisma } from '../db.js';
 import { splitTablesFromMarkdown } from '../format-tables.js';
 import { buildHtmlActionCustomId, cancelHtmlActionsForOwner, registerHtmlAction, } from '../html-actions.js';
 import * as errore from 'errore';
 import { GitCommandError } from '../errors.js';
+import { resolveWorkingDirectory } from '../discord-utils.js';
 import { deleteWorktree, git, getDefaultBranch } from '../worktrees.js';
 // Extracts the git stderr from a deleteWorktree error via errore.findCause.
 // Chain: Error { cause: GitCommandError { cause: CommandError { stderr } } }.
@@ -175,9 +176,12 @@ async function resolveGitStatuses({ worktrees, timeout, }) {
         clearTimeout(timer);
     }
 }
-async function getRecentWorktrees() {
+async function getRecentWorktrees({ projectDirectory, }) {
     const prisma = await getPrisma();
     return await prisma.thread_worktrees.findMany({
+        where: {
+            project_directory: projectDirectory,
+        },
         orderBy: { created_at: 'desc' },
         take: 10,
     });
@@ -185,10 +189,21 @@ async function getRecentWorktrees() {
 function getWorktreesActionOwnerKey({ userId, channelId, }) {
     return `worktrees:${userId}:${channelId}`;
 }
-async function renderWorktreesReply({ guildId, userId, channelId, notice, editReply, }) {
+function isProjectChannel(channel) {
+    if (!channel) {
+        return false;
+    }
+    return [
+        ChannelType.GuildText,
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+}
+async function renderWorktreesReply({ guildId, userId, channelId, projectDirectory, notice, editReply, }) {
     const ownerKey = getWorktreesActionOwnerKey({ userId, channelId });
     cancelHtmlActionsForOwner(ownerKey);
-    const worktrees = await getRecentWorktrees();
+    const worktrees = await getRecentWorktrees({ projectDirectory });
     if (worktrees.length === 0) {
         const message = notice ? `${notice}\n\nNo worktrees found.` : 'No worktrees found.';
         const textDisplay = {
@@ -269,10 +284,38 @@ async function handleDeleteWorktreeAction({ interaction, threadId, }) {
     }
     const worktree = await getThreadWorktree(threadId);
     if (!worktree) {
+        if (!isProjectChannel(interaction.channel)) {
+            await interaction.editReply({
+                components: [
+                    {
+                        type: ComponentType.TextDisplay,
+                        content: 'This action can only be used in a project channel or thread.',
+                    },
+                ],
+                flags: MessageFlags.IsComponentsV2,
+            });
+            return;
+        }
+        const resolved = await resolveWorkingDirectory({
+            channel: interaction.channel,
+        });
+        if (!resolved) {
+            await interaction.editReply({
+                components: [
+                    {
+                        type: ComponentType.TextDisplay,
+                        content: 'Could not determine the project folder for this channel.',
+                    },
+                ],
+                flags: MessageFlags.IsComponentsV2,
+            });
+            return;
+        }
         await renderWorktreesReply({
             guildId,
             userId: interaction.user.id,
             channelId: interaction.channelId,
+            projectDirectory: resolved.projectDirectory,
             notice: 'Worktree was already removed.',
             editReply: (options) => {
                 return interaction.editReply(options);
@@ -285,6 +328,7 @@ async function handleDeleteWorktreeAction({ interaction, threadId, }) {
             guildId,
             userId: interaction.user.id,
             channelId: interaction.channelId,
+            projectDirectory: worktree.project_directory,
             notice: `Cannot delete \`${worktree.worktree_name}\` because it is ${worktree.status}.`,
             editReply: (options) => {
                 return interaction.editReply(options);
@@ -319,6 +363,7 @@ async function handleDeleteWorktreeAction({ interaction, threadId, }) {
         guildId,
         userId: interaction.user.id,
         channelId: interaction.channelId,
+        projectDirectory: worktree.project_directory,
         notice: `Deleted \`${worktree.worktree_name}\`.`,
         editReply: (options) => {
             return interaction.editReply(options);
@@ -326,10 +371,28 @@ async function handleDeleteWorktreeAction({ interaction, threadId, }) {
     });
 }
 export async function handleWorktreesCommand({ command, }) {
+    const channel = command.channel;
     const guildId = command.guildId;
-    if (!guildId) {
+    if (!guildId || !channel) {
+        await command.reply({
+            content: 'This command can only be used in a server channel.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    if (!isProjectChannel(channel)) {
+        await command.reply({
+            content: 'This command can only be used in a project channel or thread.',
+            flags: MessageFlags.Ephemeral,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
         await command.reply({
-            content: 'This command can only be used in a server.',
+            content: 'Could not determine the project folder for this channel.',
             flags: MessageFlags.Ephemeral,
         });
         return;
@@ -339,6 +402,7 @@ export async function handleWorktreesCommand({ command, }) {
         guildId,
         userId: command.user.id,
         channelId: command.channelId,
+        projectDirectory: resolved.projectDirectory,
         editReply: (options) => {
             return command.editReply(options);
         },

package/dist/context-awareness-plugin.js

@@ -2,7 +2,7 @@
 // - Git branch / detached HEAD changes
 // - Working directory (pwd) changes (e.g. after /new-worktree mid-session)
 // - MEMORY.md table of contents on first message
-// - Idle time gap detection with timestamps
+// - MEMORY.md reminder after a large assistant reply
 // - Onboarding tutorial instructions (when TUTORIAL_WELCOME_TEXT detected)
 //
 // Synthetic parts are hidden from the TUI but sent to the model, keeping it
@@ -19,18 +19,18 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as errore from 'errore';
-import { createLogger, formatErrorWithStack, LogPrefix, setLogFilePath, } from './logger.js';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
 import { setDataDir } from './config.js';
 import { initSentry, notifyError } from './sentry.js';
-import { execAsync } from './worktrees.js';
+import { execAsync } from './exec-async.js';
 import { condenseMemoryMd } from './condense-memory.js';
 import { ONBOARDING_TUTORIAL_INSTRUCTIONS, TUTORIAL_WELCOME_TEXT, } from './onboarding-tutorial.js';
-const logger = createLogger(LogPrefix.OPENCODE);
+const logger = createPluginLogger('OPENCODE');
 function createSessionState() {
     return {
         gitState: undefined,
-        lastMessageTime: undefined,
         memoryInjected: false,
+        lastMemoryReminderAssistantMessageId: undefined,
         tutorialInjected: false,
         resolvedDirectory: undefined,
         announcedDirectory: undefined,
@@ -65,34 +65,31 @@ export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
             `Do NOT read, write, or edit files under ${priorDirectory}.]`,
     };
 }
-const TEN_MINUTES = 10 * 60 * 1000;
-export function shouldInjectTimeGap({ lastMessageTime, now, }) {
-    if (!lastMessageTime) {
+const MEMORY_REMINDER_OUTPUT_TOKENS = 12_000;
+function getOutputTokenTotal(tokens) {
+    return Math.max(0, tokens.output + tokens.reasoning);
+}
+export function shouldInjectMemoryReminderFromLatestAssistant({ lastMemoryReminderAssistantMessageId, latestAssistantMessage, threshold = MEMORY_REMINDER_OUTPUT_TOKENS, }) {
+    if (!latestAssistantMessage) {
         return { inject: false };
     }
-    const elapsed = now - lastMessageTime;
-    if (elapsed < TEN_MINUTES) {
+    if (latestAssistantMessage.role !== 'assistant') {
         return { inject: false };
     }
-    const totalMinutes = Math.floor(elapsed / 60_000);
-    const hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes % 60;
-    const elapsedStr = hours > 0 ? `${hours}h ${minutes}m` : `${totalMinutes}m`;
-    const utcStr = new Date(now)
-        .toISOString()
-        .replace('T', ' ')
-        .replace(/\.\d+Z$/, ' UTC');
-    const localTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const localStr = new Date(now).toLocaleString('en-US', {
-        timeZone: localTz,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        hour12: false,
-    });
-    return { inject: true, elapsedStr, utcStr, localStr, localTz };
+    if (typeof latestAssistantMessage.time?.completed !== 'number') {
+        return { inject: false };
+    }
+    if (!latestAssistantMessage.tokens) {
+        return { inject: false };
+    }
+    if (lastMemoryReminderAssistantMessageId === latestAssistantMessage.id) {
+        return { inject: false };
+    }
+    const outputTokens = getOutputTokenTotal(latestAssistantMessage.tokens);
+    if (outputTokens < threshold) {
+        return { inject: false };
+    }
+    return { inject: true, assistantMessageId: latestAssistantMessage.id };
 }
 export function shouldInjectTutorial({ alreadyInjected, parts, }) {
     if (alreadyInjected) {
@@ -177,7 +174,7 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
     const dataDir = process.env.KIMAKI_DATA_DIR;
     if (dataDir) {
         setDataDir(dataDir);
-        setLogFilePath(dataDir);
+        setPluginLogFilePath(dataDir);
     }
     // Single Map for all per-session state. One entry per session, one
     // delete on cleanup — no parallel Maps that can drift out of sync.
@@ -219,7 +216,6 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                     // -- Find first non-synthetic user text part --
                     // All remaining injections (branch, pwd, memory, time gap) only
                     // apply to real user messages, not empty or synthetic-only messages.
-                    const now = Date.now();
                     const first = output.parts.find((part) => {
                         if (part.type !== 'text') {
                             return true;
@@ -230,6 +226,20 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                         return;
                     }
                     const messageID = first.messageID;
+                    const latestAssistantMessageResult = await errore.tryAsync(() => {
+                        return client.session.messages({
+                            path: { id: sessionID },
+                            query: { directory, limit: 20 },
+                        });
+                    });
+                    const latestAssistantMessage = latestAssistantMessageResult instanceof Error
+                        ? undefined
+                        : [...(latestAssistantMessageResult.data || [])]
+                            .reverse()
+                            .find((entry) => {
+                            return entry.info.role === 'assistant';
+                        })
+                            ?.info;
                     // -- Resolve session working directory --
                     const sessionDirectory = await resolveSessionDirectory({
                         client,
@@ -278,34 +288,26 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                                 sessionID,
                                 messageID,
                                 type: 'text',
-                                text: `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, make headings detailed and descriptive since they are the only thing visible in this prompt. You can update MEMORY.md to store learnings, tips, insights that will help prevent same mistakes, and context worth preserving across sessions.</system-reminder>`,
+                                text: `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>`,
                                 synthetic: true,
                             });
                         }
                     }
-                    // -- Time since last message --
-                    const timeGapResult = shouldInjectTimeGap({
-                        lastMessageTime: state.lastMessageTime,
-                        now,
+                    const memoryReminder = shouldInjectMemoryReminderFromLatestAssistant({
+                        lastMemoryReminderAssistantMessageId: state.lastMemoryReminderAssistantMessageId,
+                        latestAssistantMessage,
                     });
-                    state.lastMessageTime = now;
-                    if (timeGapResult.inject) {
-                        output.parts.push({
-                            id: `prt_${crypto.randomUUID()}`,
-                            sessionID,
-                            messageID,
-                            type: 'text',
-                            text: `[${timeGapResult.elapsedStr} since last message | UTC: ${timeGapResult.utcStr} | Local (${timeGapResult.localTz}): ${timeGapResult.localStr}]`,
-                            synthetic: true,
-                        });
+                    if (memoryReminder.inject) {
                         output.parts.push({
                             id: `prt_${crypto.randomUUID()}`,
                             sessionID,
                             messageID,
                             type: 'text',
-                            text: '<system-reminder>Long gap since last message. If the previous conversation had important learnings, tips, insights that will help prevent same mistakes, or context worth preserving, update MEMORY.md before starting the new task.</system-reminder>',
+                            text: '<system-reminder>The previous assistant message was large. If the conversation had non-obvious learnings that prevent future mistakes and are not already in code comments or AGENTS.md, add them to MEMORY.md with concise titles and brief content (2-3 sentences max).</system-reminder>',
                             synthetic: true,
                         });
+                        state.lastMemoryReminderAssistantMessageId =
+                            memoryReminder.assistantMessageId;
                     }
                     // -- Branch injection (last synthetic part) --
                     const branchResult = shouldInjectBranch({
@@ -329,12 +331,12 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                 },
             });
             if (hookResult instanceof Error) {
-                logger.warn(`[context-awareness-plugin] ${formatErrorWithStack(hookResult)}`);
+                logger.warn(`[context-awareness-plugin] ${formatPluginErrorWithStack(hookResult)}`);
                 void notifyError(hookResult, 'context-awareness plugin chat.message hook failed');
             }
         },
         // Clean up per-session state when sessions are deleted.
-        // Single delete instead of 5 parallel Map/Set deletes.
+        // Single delete instead of parallel Map/Set deletes.
         event: async ({ event }) => {
             const cleanupResult = await errore.tryAsync({
                 try: async () => {
@@ -352,7 +354,7 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                 },
             });
             if (cleanupResult instanceof Error) {
-                logger.warn(`[context-awareness-plugin] ${formatErrorWithStack(cleanupResult)}`);
+                logger.warn(`[context-awareness-plugin] ${formatPluginErrorWithStack(cleanupResult)}`);
                 void notifyError(cleanupResult, 'context-awareness plugin event hook failed');
             }
         },

package/dist/context-awareness-plugin.test.js

@@ -1,6 +1,6 @@
 // Tests for context-awareness directory switch reminders.
 import { describe, expect, test } from 'vitest';
-import { shouldInjectPwd } from './context-awareness-plugin.js';
+import { shouldInjectPwd, shouldInjectMemoryReminderFromLatestAssistant, } from './context-awareness-plugin.js';
 describe('shouldInjectPwd', () => {
     test('does not inject when current directory matches announced directory', () => {
         const result = shouldInjectPwd({
@@ -55,3 +55,70 @@ describe('shouldInjectPwd', () => {
     `);
     });
 });
+describe('shouldInjectMemoryReminderFromLatestAssistant', () => {
+    test('does not trigger before threshold', () => {
+        const result = shouldInjectMemoryReminderFromLatestAssistant({
+            latestAssistantMessage: {
+                id: 'msg_asst_1',
+                role: 'assistant',
+                time: { completed: 1 },
+                tokens: {
+                    input: 1_000,
+                    output: 3_000,
+                    reasoning: 500,
+                    cache: { read: 0, write: 0 },
+                },
+            },
+            threshold: 10_000,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+    test('triggers when latest assistant message exceeds threshold', () => {
+        const result = shouldInjectMemoryReminderFromLatestAssistant({
+            latestAssistantMessage: {
+                id: 'msg_asst_2',
+                role: 'assistant',
+                time: { completed: 2 },
+                tokens: {
+                    input: 2_000,
+                    output: 2_200,
+                    reasoning: 400,
+                    cache: { read: 0, write: 0 },
+                },
+            },
+            threshold: 2_000,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "assistantMessageId": "msg_asst_2",
+        "inject": true,
+      }
+    `);
+    });
+    test('does not trigger again for the same reminded assistant message', () => {
+        const result = shouldInjectMemoryReminderFromLatestAssistant({
+            lastMemoryReminderAssistantMessageId: 'msg_asst_3',
+            latestAssistantMessage: {
+                id: 'msg_asst_3',
+                role: 'assistant',
+                time: { completed: 3 },
+                tokens: {
+                    input: 2_000,
+                    output: 2_200,
+                    reasoning: 400,
+                    cache: { read: 0, write: 0 },
+                },
+            },
+            threshold: 10_000,
+        });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "inject": false,
+      }
+    `);
+    });
+});