kimaki 0.28.0 → 0.30.0

package/dist/cache-drift-plugin.js

@@ -2,8 +2,8 @@
 // When the system prompt changes between user messages, it logs a warning
 // with addition/deletion line counts so you know context cache was discarded.
 // This helps spot plugins that mutate the system prompt unexpectedly.
-import { diffLines } from 'diff';
 import * as errore from 'errore';
+import { countSystemPromptDiffLines, writeSystemPromptPatch, } from './cache-rewrite.js';
 import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath } from './plugin-logger.js';
 import { initSentry, notifyError } from './sentry.js';
 const logger = createPluginLogger('OPENCODE');
@@ -27,18 +27,6 @@ function shouldSuppressDriftWarning({ previousContext, currentContext, }) {
         || previousContext.model !== currentContext.model
         || previousContext.directory !== currentContext.directory);
 }
-function countDiffLines({ beforeText, afterText, }) {
-    const changes = diffLines(beforeText, afterText);
-    let additions = 0;
-    let deletions = 0;
-    for (const change of changes) {
-        if (change.added)
-            additions += change.count ?? 0;
-        if (change.removed)
-            deletions += change.count ?? 0;
-    }
-    return { additions, deletions };
-}
 function getOrCreateSessionState({ sessions, sessionId, }) {
     const existing = sessions.get(sessionId);
     if (existing)
@@ -56,7 +44,7 @@ function getOrCreateSessionState({ sessions, sessionId, }) {
     sessions.set(sessionId, state);
     return state;
 }
-function handleSystemTransform({ input, output, sessions, }) {
+function handleSystemTransform({ input, output, sessions, dataDir, }) {
     const sessionId = input.sessionID;
     if (!sessionId)
         return;
@@ -79,12 +67,31 @@ function handleSystemTransform({ input, output, sessions, }) {
     })) {
         return;
     }
-    const { additions, deletions } = countDiffLines({
+    const { additions, deletions } = countSystemPromptDiffLines({
+        beforeText: previousPrompt,
+        afterText: currentPrompt,
+    });
+    const model = state.currentTurnContext?.model;
+    const agent = state.currentTurnContext?.agent;
+    if (!dataDir) {
+        logger.warn(`[cache-drift] system prompt changed for session ${sessionId} `
+            + `(+${additions} / -${deletions}), no data dir for patch`);
+        return;
+    }
+    void writeSystemPromptPatch({
+        dataDir,
+        sessionId,
         beforeText: previousPrompt,
         afterText: currentPrompt,
+        model,
+        agent,
+    }).then((filePath) => {
+        logger.warn(`[cache-drift] system prompt changed for session ${sessionId} `
+            + `(+${additions} / -${deletions}) patch=${filePath}`);
+    }).catch((error) => {
+        logger.warn(`[cache-drift] ${formatPluginErrorWithStack(error)}`);
+        void notifyError(error, 'cache drift patch write failed');
     });
-    logger.warn(`[cache-drift] context cache discarded for session ${sessionId}: `
-        + `system prompt changed since previous message (+${additions} / -${deletions} lines)`);
 }
 function getDeletedSessionId({ event }) {
     if (event.type !== 'session.deleted')
@@ -131,7 +138,7 @@ const cacheDriftPlugin = async ({ directory }) => {
                     state.pendingCompareTimeout = setTimeout(() => {
                         state.pendingCompareTimeout = undefined;
                         try {
-                            handleSystemTransform({ input, output, sessions });
+                            handleSystemTransform({ input, output, sessions, dataDir });
                         }
                         catch (err) {
                             logger.warn(`[cache-drift] ${formatPluginErrorWithStack(err)}`);

package/dist/cache-rewrite.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createTwoFilesPatch, diffLines } from 'diff';
+export const CACHE_REWRITES_DIR = 'cache-rewrites';
+export function countSystemPromptDiffLines({ beforeText, afterText, }) {
+    const changes = diffLines(beforeText, afterText);
+    let additions = 0;
+    let deletions = 0;
+    for (const change of changes) {
+        if (change.added)
+            additions += change.count ?? 0;
+        if (change.removed)
+            deletions += change.count ?? 0;
+    }
+    return { additions, deletions };
+}
+export function formatSystemPromptPatch({ beforeText, afterText, sessionId, model, agent, }) {
+    const { additions, deletions } = countSystemPromptDiffLines({ beforeText, afterText });
+    const patch = createTwoFilesPatch('system-before.txt', 'system-after.txt', beforeText, afterText, undefined, undefined, { context: 3 });
+    return [
+        `session: ${sessionId}`,
+        `model: ${model ?? 'unknown'}`,
+        `agent: ${agent ?? 'unknown'}`,
+        `system +${additions} -${deletions}`,
+        '',
+        patch,
+    ].join('\n');
+}
+export function cacheRewritePatchPath({ dataDir, sessionId, now = Date.now(), }) {
+    const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(dataDir, CACHE_REWRITES_DIR, `${now}-${safeSessionId}.patch`);
+}
+export async function writeSystemPromptPatch({ dataDir, sessionId, beforeText, afterText, model, agent, now, }) {
+    const filePath = cacheRewritePatchPath({ dataDir, sessionId, now });
+    const dirPath = path.dirname(filePath);
+    await fs.promises.mkdir(dirPath, { recursive: true, mode: 0o700 });
+    await fs.promises.writeFile(filePath, formatSystemPromptPatch({ beforeText, afterText, sessionId, model, agent }), { encoding: 'utf8', mode: 0o600 });
+    return filePath;
+}

package/dist/cache-rewrite.test.js

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, expect, test } from 'vitest';
+import { countSystemPromptDiffLines, formatSystemPromptPatch, writeSystemPromptPatch, } from './cache-rewrite.js';
+const tempDirs = [];
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+test('counts added and removed system prompt lines', () => {
+    expect(countSystemPromptDiffLines({
+        beforeText: 'keep\nold line\n',
+        afterText: 'keep\nnew line\nextra\n',
+    })).toEqual({ additions: 2, deletions: 1 });
+});
+test('writes a unified patch only for the caller', async () => {
+    const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-cache-rewrite-'));
+    tempDirs.push(dataDir);
+    const filePath = await writeSystemPromptPatch({
+        dataDir,
+        sessionId: 'ses_test',
+        beforeText: 'alpha\n',
+        afterText: 'beta\n',
+        model: 'openai/gpt-5',
+        agent: 'build',
+        now: 1_700_000_000_000,
+    });
+    expect(path.basename(filePath)).toBe('1700000000000-ses_test.patch');
+    const text = fs.readFileSync(filePath, 'utf8');
+    expect(text).toContain('session: ses_test');
+    expect(text).toContain('system +1 -1');
+    expect(text).toContain('-alpha');
+    expect(text).toContain('+beta');
+    expect(formatSystemPromptPatch({
+        beforeText: 'alpha\n',
+        afterText: 'beta\n',
+        sessionId: 'ses_test',
+    })).toContain('--- system-before.txt');
+});

package/dist/channel-management.js

@@ -4,7 +4,7 @@
 import { ChannelType, } from 'discord.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, } from './database.js';
+import { getChannelDirectory, setChannelDirectory, findChannelsByDirectory, listTrackedTextChannels, getGuildCategories, setGuildCategoryId, } from './database.js';
 import { getProjectsDir } from './config.js';
 import { execAsync } from './worktrees.js';
 import { createLogger, LogPrefix } from './logger.js';
@@ -39,41 +39,117 @@ async function trackProjectRegistered({ projectKind, source, }) {
     trackEvent('project_registered', props);
 }
 const logger = createLogger(LogPrefix.CHANNEL);
-export async function ensureKimakiCategory(guild, botName) {
-    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki kimaki"
+function defaultCategoryName(kind, botName) {
     const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    const categoryName = botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
-    const existingCategory = guild.channels.cache.find((channel) => {
-        if (channel.type !== ChannelType.GuildCategory) {
-            return false;
+    if (kind === 'audio') {
+        return botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
+    }
+    return botName && !isKimakiBot ? `Kimaki ${botName}` : 'Kimaki';
+}
+function defaultKimakiChannelName({ botName, isGatewayMode, }) {
+    if (isGatewayMode || !botName)
+        return 'kimaki';
+    const sanitized = botName
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    if (!sanitized || sanitized === 'kimaki')
+        return 'kimaki';
+    return `kimaki-${sanitized}`.slice(0, 100);
+}
+const categoryEnsures = new Map();
+function ensureCategorySerialized({ key, run, }) {
+    const existing = categoryEnsures.get(key);
+    if (existing)
+        return existing;
+    const promise = run().finally(() => {
+        if (categoryEnsures.get(key) === promise) {
+            categoryEnsures.delete(key);
         }
-        return channel.name.toLowerCase() === categoryName.toLowerCase();
     });
-    if (existingCategory) {
-        return existingCategory;
+    categoryEnsures.set(key, promise);
+    return promise;
+}
+function isUnknownDiscordChannel(error) {
+    const code = error instanceof Error ? Reflect.get(error, 'code') : undefined;
+    const status = error instanceof Error ? Reflect.get(error, 'status') : undefined;
+    return code === 10003 || status === 404;
+}
+function isCategoryChannel(channel) {
+    return channel?.type === ChannelType.GuildCategory;
+}
+async function fetchCategoryById(guild, categoryId) {
+    const cached = guild.channels.cache.get(categoryId);
+    if (isCategoryChannel(cached))
+        return cached;
+    try {
+        const fetched = await guild.channels.fetch(categoryId);
+        return isCategoryChannel(fetched) ? fetched : null;
+    }
+    catch (error) {
+        if (isUnknownDiscordChannel(error))
+            return null;
+        throw error;
     }
-    return guild.channels.create({
-        name: categoryName,
-        type: ChannelType.GuildCategory,
-    });
 }
-export async function ensureKimakiAudioCategory(guild, botName) {
-    // Skip appending bot name if it's already "kimaki" to avoid "Kimaki Audio kimaki"
-    const isKimakiBot = botName?.toLowerCase() === 'kimaki';
-    const categoryName = botName && !isKimakiBot ? `Kimaki Audio ${botName}` : 'Kimaki Audio';
-    const existingCategory = guild.channels.cache.find((channel) => {
-        if (channel.type !== ChannelType.GuildCategory) {
-            return false;
-        }
-        return channel.name.toLowerCase() === categoryName.toLowerCase();
+async function adoptParentFromTrackedChannels({ guild, channelType, }) {
+    const mappings = await findChannelsByDirectory({ channelType });
+    const channels = await guild.channels.fetch();
+    for (const row of mappings) {
+        if (row.guild_id && row.guild_id !== guild.id)
+            continue;
+        const channel = channels.get(row.channel_id);
+        if (!channel?.parentId)
+            continue;
+        const parent = await fetchCategoryById(guild, channel.parentId);
+        if (parent)
+            return parent;
+    }
+    return null;
+}
+async function resolveKimakiCategory({ guild, kind, botName, }) {
+    const stored = await getGuildCategories(guild.id);
+    const storedId = kind === 'audio' ? stored?.audio_category_id : stored?.category_id;
+    if (storedId) {
+        const existing = await fetchCategoryById(guild, storedId);
+        if (existing)
+            return existing;
+    }
+    const adopted = await adoptParentFromTrackedChannels({
+        guild,
+        channelType: kind === 'audio' ? 'voice' : 'text',
     });
-    if (existingCategory) {
-        return existingCategory;
+    if (adopted) {
+        await setGuildCategoryId({
+            guildId: guild.id,
+            kind,
+            categoryId: adopted.id,
+        });
+        return adopted;
     }
-    return guild.channels.create({
-        name: categoryName,
+    const created = await guild.channels.create({
+        name: defaultCategoryName(kind, botName),
         type: ChannelType.GuildCategory,
     });
+    await setGuildCategoryId({
+        guildId: guild.id,
+        kind,
+        categoryId: created.id,
+    });
+    return created;
+}
+export function ensureKimakiCategory(guild, botName) {
+    return ensureCategorySerialized({
+        key: `${guild.id}:text`,
+        run: () => resolveKimakiCategory({ guild, kind: 'text', botName }),
+    });
+}
+export function ensureKimakiAudioCategory(guild, botName) {
+    return ensureCategorySerialized({
+        key: `${guild.id}:audio`,
+        run: () => resolveKimakiCategory({ guild, kind: 'audio', botName }),
+    });
 }
 export async function createProjectChannels({ guild, projectDirectory, botName, enableVoiceChannels = false, analyticsSource = 'cli', }) {
     const baseName = path.basename(projectDirectory);
@@ -92,6 +168,7 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
         channelId: textChannel.id,
         directory: projectDirectory,
         channelType: 'text',
+        guildId: guild.id,
     });
     await trackProjectRegistered({
         projectKind: 'user',
@@ -109,6 +186,7 @@ export async function createProjectChannels({ guild, projectDirectory, botName,
             channelId: voiceChannel.id,
             directory: projectDirectory,
             channelType: 'voice',
+            guildId: guild.id,
         });
         voiceChannelId = voiceChannel.id;
     }
@@ -158,8 +236,9 @@ const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not c
  * Directory is ~/.kimaki/projects/kimaki, git-initialized with a .gitignore.
  *
  * Idempotency: checks the database for an existing channel mapped to the
- * kimaki projects directory. Also scans guild channels by name+category
- * as a fallback for channels created before DB mapping existed.
+ * kimaki projects directory. Also scans this machine's category for the
+ * exact default channel name as a fallback for channels created before
+ * DB mapping existed.
  */
 export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
     const projectDirectory = getDefaultKimakiDirectory();
@@ -209,11 +288,9 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         logger.log(`Default kimaki channel was previously provisioned for guild ${guild.name} (${guild.id}) as ${staleForThisGuild.channel_id}, but no longer exists. Skipping recreation.`);
         return null;
     }
-    // 2. Fallback: detect existing channel by name+category.
-    // If a "kimaki" channel already exists in the guild but is NOT in our local
-    // DB, it was likely created by another kimaki instance (different machine).
-    // Do NOT adopt it — just skip channel creation entirely to avoid both
-    // instances fighting over the same channel.
+    // 2. Fallback: detect an existing default channel in THIS machine's group.
+    // A #kimaki channel in another machine's group is ignored.
+    const channelName = defaultKimakiChannelName({ botName, isGatewayMode });
     const kimakiCategory = await ensureKimakiCategory(guild, botName);
     const existingByName = guild.channels.cache.find((ch) => {
         if (ch.type !== ChannelType.GuildText) {
@@ -222,10 +299,10 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         if (ch.parentId !== kimakiCategory.id) {
             return false;
         }
-        return ch.name === 'kimaki' || ch.name.startsWith('kimaki-');
+        return ch.name === channelName;
     });
     if (existingByName) {
-        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}, but it is not in our DB — skipping (likely owned by another kimaki instance)`);
+        logger.log(`Found existing default kimaki channel by name: ${existingByName.id}. Skipping recreation.`);
         return null;
     }
     // Git init — gracefully skip if git is not installed
@@ -244,21 +321,6 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
     if (!fs.existsSync(gitignorePath)) {
         fs.writeFileSync(gitignorePath, DEFAULT_GITIGNORE);
     }
-    // Channel name: "kimaki-{botName}" for self-hosted, "kimaki" for gateway
-    const channelName = (() => {
-        if (isGatewayMode || !botName) {
-            return 'kimaki';
-        }
-        const sanitized = botName
-            .toLowerCase()
-            .replace(/[^a-z0-9-]/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-|-$/g, '');
-        if (!sanitized || sanitized === 'kimaki') {
-            return 'kimaki';
-        }
-        return `kimaki-${sanitized}`.slice(0, 100);
-    })();
     const textChannel = await guild.channels.create({
         name: channelName,
         type: ChannelType.GuildText,

package/dist/cli-commands/misc.js

@@ -24,6 +24,7 @@ import { execAsync, validateWorktreeDirectory } from '../worktrees.js';
 import { upgrade, getCurrentVersion } from '../upgrade.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload } from '../task-schedule.js';
 import { EXIT_NO_RESTART, formatMemberLookupUnavailableMessage, formatRelativeTime, formatTaskScheduleLine, isDiscordMemberLookupUnavailable, isGuildMemberSearchResult, isThreadChannelType, printDiscordInstallUrlAndExit, resolveBotCredentials, resolveDiscordUserOption, sendDiscordMessageWithOptionalAttachment, } from '../cli-runner.js';
+import { resolveUploadToDiscordSessionId } from '../bash-tool-schema-plugin.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 const cli = goke();
 cli
@@ -31,7 +32,9 @@ cli
     .option('-s, --session <sessionId>', 'OpenCode session ID')
     .action(async (files, options) => {
     try {
-        const { session: sessionId } = options;
+        const sessionId = resolveUploadToDiscordSessionId({
+            flagSessionId: options.session,
+        });
         if (!sessionId) {
             cliLogger.error('Session ID is required. Use --session <sessionId>');
             process.exit(EXIT_NO_RESTART);

package/dist/cli-commands/project.js

@@ -12,7 +12,7 @@ import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
 import { getDefaultKimakiDirectory } from '../channel-management.js';
-import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError } from '../database.js';
+import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory, findRegisteredTextChannelForDirectory, formatProjectAlreadyRegisteredError, listGuildCategoryIds } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
 import { formatWorktreeName, formatAutoWorktreeName } from '../commands/new-worktree.js';
@@ -88,7 +88,7 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
-    .option('--all', 'Include remote projects from other machines (scans Kimaki category in Discord)')
+    .option('--all', 'Include remote projects from other machines (scans Kimaki groups in Discord)')
     .option('-g, --guild <guildId>', 'Discord guild/server ID to scan (used with --all when no local projects exist)')
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
@@ -158,12 +158,15 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         let guildScanFailures = 0;
+        const storedCategoryIds = new Set(await listGuildCategoryIds());
         for (const guildId of uniqueGuildIds) {
             try {
                 const guildChannels = (await rest.get(Routes.guildChannels(guildId)));
-                // Find Kimaki category channels (type 4 = GuildCategory)
+                // Kimaki groups: name still starts with Kimaki, or this machine stored the id
+                // after a rename. Other machines' renamed groups cannot be found by name.
                 const kimakiCategoryIds = new Set(guildChannels
-                    .filter((ch) => ch.type === 4 && /^kimaki(\s|$)/i.test(ch.name))
+                    .filter((ch) => ch.type === 4 &&
+                    (/^kimaki(\s|$)/i.test(ch.name) || storedCategoryIds.has(ch.id)))
                     .map((ch) => ch.id));
                 // Find text channels (type 0) in Kimaki categories that are not in our local DB
                 for (const ch of guildChannels) {