kimaki 0.4.92 → 0.4.94

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

@@ -735,7 +735,8 @@ describe('agent model resolution', () => {
         --- from: assistant (TestBot)
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
-        Switched to **plan** agent for this session next messages (was **test-agent**)
+        Switched to **plan** agent for this session (was **test-agent**)
+        The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg
         --- from: assistant (TestBot)

package/dist/anthropic-auth-plugin.js

@@ -627,6 +627,15 @@ async function getFreshOAuth(getAuth, client) {
 // --- Plugin export ---
 const AnthropicAuthPlugin = async ({ client }) => {
     return {
+        "experimental.chat.system.transform": async (input, output) => {
+            if (input.model.providerID !== ('anthropic'))
+                return;
+            const opencodePromptPart = output.system.findIndex(x => x?.includes('https://github.com/anomalyco/opencode'));
+            // Remove the OpenCode system prompt part if present
+            if (opencodePromptPart !== -1) {
+                output.system.splice(opencodePromptPart, 1);
+            }
+        },
         auth: {
             provider: 'anthropic',
             async loader(getAuth, provider) {
@@ -694,6 +703,13 @@ const AnthropicAuthPlugin = async ({ client }) => {
                             if (shouldRotateAuth(response.status, bodyText)) {
                                 const rotated = await rotateAnthropicAccount(freshAuth, client);
                                 if (rotated) {
+                                    // Show toast notification so Discord thread shows the rotation
+                                    client.tui.showToast({
+                                        body: {
+                                            message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
+                                            variant: 'info',
+                                        },
+                                    }).catch(() => { });
                                     const retryAuth = await getFreshOAuth(getAuth, client);
                                     if (retryAuth) {
                                         response = await runRequest(retryAuth);

package/dist/anthropic-auth-plugin.test.js

@@ -67,7 +67,13 @@ describe('rotateAnthropicAccount', () => {
         const rotated = await rotateAnthropicAccount(firstAccount, client);
         const store = await loadAccountStore();
         const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(rotated).toMatchObject({ refresh: 'refresh-second' });
+        expect(rotated).toMatchObject({
+            auth: { refresh: 'refresh-second' },
+            fromLabel: '#1 (refresh-...irst)',
+            toLabel: '#2 (refresh-...cond)',
+            fromIndex: 0,
+            toIndex: 1,
+        });
         expect(store.activeIndex).toBe(1);
         expect(authJson.anthropic?.refresh).toBe('refresh-second');
         expect(authSetCalls).toEqual([

package/dist/anthropic-auth-state.js

@@ -94,6 +94,12 @@ export async function loadAccountStore() {
 export async function saveAccountStore(store) {
     await writeJson(accountsFilePath(), normalizeAccountStore(store));
 }
+/** Short label for an account: first 8 + last 4 chars of refresh token. */
+export function accountLabel(account, index) {
+    const r = account.refresh;
+    const short = r.length > 12 ? `${r.slice(0, 8)}...${r.slice(-4)}` : r;
+    return index !== undefined ? `#${index + 1} (${short})` : short;
+}
 function findCurrentAccountIndex(store, auth) {
     if (!store.accounts.length)
         return 0;
@@ -165,10 +171,14 @@ export async function rotateAnthropicAccount(auth, client) {
         if (store.accounts.length < 2)
             return undefined;
         const currentIndex = findCurrentAccountIndex(store, auth);
+        const currentAccount = store.accounts[currentIndex];
         const nextIndex = (currentIndex + 1) % store.accounts.length;
         const nextAccount = store.accounts[nextIndex];
         if (!nextAccount)
             return undefined;
+        const fromLabel = currentAccount
+            ? accountLabel(currentAccount, currentIndex)
+            : accountLabel(auth, currentIndex);
         nextAccount.lastUsed = Date.now();
         store.activeIndex = nextIndex;
         await saveAccountStore(store);
@@ -179,7 +189,13 @@ export async function rotateAnthropicAccount(auth, client) {
             expires: nextAccount.expires,
         };
         await setAnthropicAuth(nextAuth, client);
-        return nextAuth;
+        return {
+            auth: nextAuth,
+            fromLabel,
+            toLabel: accountLabel(nextAccount, nextIndex),
+            fromIndex: currentIndex,
+            toIndex: nextIndex,
+        };
     });
 }
 export async function removeAccount(index) {

package/dist/cli.js

@@ -32,7 +32,7 @@ import { backgroundUpgradeKimaki, upgrade, getCurrentVersion, } from './upgrade.
 import { startHranaServer } from './hrana-server.js';
 import { startIpcPolling, stopIpcPolling } from './ipc-polling.js';
 import { getPromptPreview, parseSendAtValue, parseScheduledTaskPayload, serializeScheduledTaskPayload, } from './task-schedule.js';
-import { accountsFilePath, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
+import { accountLabel, accountsFilePath, loadAccountStore, removeAccount, } from './anthropic-auth-state.js';
 const cliLogger = createLogger(LogPrefix.CLI);
 // Gateway bot mode constants.
 // KIMAKI_GATEWAY_APP_ID is the Discord Application ID of the gateway bot.
@@ -2234,8 +2234,7 @@ cli
     }
     store.accounts.forEach((account, index) => {
         const active = index === store.activeIndex ? '*' : ' ';
-        const label = `${account.refresh.slice(0, 8)}...${account.refresh.slice(-4)}`;
-        console.log(`${active} ${index + 1}. ${label}`);
+        console.log(`${active} ${index + 1}. ${accountLabel(account)}`);
     });
     process.exit(0);
 });

package/dist/commands/agent.js

@@ -255,7 +255,7 @@ export async function handleAgentSelectMenu(interaction) {
         await setAgentForContext({ context, agentName: selectedAgent });
         if (context.isThread && context.sessionId) {
             await interaction.editReply({
-                content: `Agent preference set for this session next messages: **${selectedAgent}**`,
+                content: `Agent preference set for this session: **${selectedAgent}**\nThe agent will change on the next message.`,
                 components: [],
             });
         }
@@ -317,7 +317,7 @@ export async function handleQuickAgentCommand({ command, appId, }) {
             : '';
         if (context.isThread && context.sessionId) {
             await command.editReply({
-                content: `Switched to **${resolvedAgentName}** agent for this session next messages${previousText}`,
+                content: `Switched to **${resolvedAgentName}** agent for this session${previousText}\nThe agent will change on the next message.`,
             });
         }
         else {

package/dist/commands/merge-worktree.js

@@ -103,15 +103,18 @@ export async function handleMergeWorktreeCommand({ command, appId, }) {
             await command.editReply('Rebase conflict detected. Asking the model to resolve...');
             await sendPromptToModel({
                 prompt: [
-                    'A rebase conflict occurred while merging this worktree into the default branch.',
+                    `A rebase conflict occurred while merging this worktree into \`${result.target}\`.`,
                     '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. 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',
+                    'Before editing anything, first understand both sides so you preserve both intentions and do not drop features or fixes.',
+                    '1. Check `git status` to see which files have conflicts and confirm the rebase is paused',
+                    `2. Find the merge base between this worktree and \`${result.target}\`, then read the commit messages from both sides since that merge base so you understand the goal of each change`,
+                    `3. Read the diffs from that merge base to both sides so you understand exactly what changed on this branch and on \`${result.target}\` before resolving conflicts`,
+                    '4. Read the commit currently being replayed in the rebase so you know the intent of the specific conflicting patch',
+                    '5. Edit the conflicted files to preserve both intended changes where possible instead of choosing one side wholesale',
+                    '6. Stage resolved files with `git add`',
+                    '7. Continue the rebase with `git rebase --continue`',
+                    '8. If git reports more conflicts, repeat steps 1-7 until the rebase finishes (no more rebase in progress, `git status` is clean)',
+                    '9. Once the rebase is fully complete, tell me so I can run `/merge-worktree` again',
                 ].join('\n'),
                 thread,
                 projectDirectory: worktreeInfo.project_directory,

package/dist/context-awareness-plugin.js

@@ -61,7 +61,7 @@ export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
         inject: true,
         text: `\n[working directory changed. Previous working directory: ${priorDirectory}. ` +
             `Current working directory: ${currentDir}. ` +
-            `You MUST read, write, and edit files only under ${currentDir}. ` +
+            `You should read, write, and edit files under ${currentDir}. ` +
             `Do NOT read, write, or edit files under ${priorDirectory}.]`,
     };
 }

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

@@ -36,7 +36,7 @@ describe('shouldInjectPwd', () => {
       {
         "inject": true,
         "text": "
-      [working directory changed. Previous working directory: /repo/main. Current working directory: /repo/worktree. You MUST read, write, and edit files only under /repo/worktree. Do NOT read, write, or edit files under /repo/main.]",
+      [working directory changed. Previous working directory: /repo/main. Current working directory: /repo/worktree. You should read, write, and edit files under /repo/worktree. Do NOT read, write, or edit files under /repo/main.]",
       }
     `);
     });
@@ -50,7 +50,7 @@ describe('shouldInjectPwd', () => {
       {
         "inject": true,
         "text": "
-      [working directory changed. Previous working directory: /repo/worktree-a. Current working directory: /repo/worktree-b. You MUST read, write, and edit files only under /repo/worktree-b. Do NOT read, write, or edit files under /repo/worktree-a.]",
+      [working directory changed. Previous working directory: /repo/worktree-a. Current working directory: /repo/worktree-b. You should read, write, and edit files under /repo/worktree-b. Do NOT read, write, or edit files under /repo/worktree-a.]",
       }
     `);
     });

package/dist/kimaki-opencode-plugin.js

@@ -11,6 +11,7 @@
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
+export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';
 export { imageOptimizerPlugin } from './image-optimizer-plugin.js';
 export { kittyGraphicsPlugin } from 'kitty-graphics-agent';

package/dist/logger.js

@@ -80,12 +80,18 @@ export function setLogFilePath(dataDir) {
 export function getLogFilePath() {
     return logFilePath;
 }
+const MAX_LOG_ARG_LENGTH = 1000;
+function truncate(str, max) {
+    if (str.length <= max)
+        return str;
+    return str.slice(0, max) + `… [truncated ${str.length - max} chars]`;
+}
 function formatArg(arg) {
     if (typeof arg === 'string') {
-        return sanitizeSensitiveText(arg, { redactPaths: false });
+        return truncate(sanitizeSensitiveText(arg, { redactPaths: false }), MAX_LOG_ARG_LENGTH);
     }
     const safeArg = sanitizeUnknownValue(arg, { redactPaths: false });
-    return util.inspect(safeArg, { colors: true, depth: 4 });
+    return truncate(util.inspect(safeArg, { colors: true, depth: 4 }), MAX_LOG_ARG_LENGTH);
 }
 export function formatErrorWithStack(error) {
     if (error instanceof Error) {

package/dist/session-handler/thread-session-runtime.js

@@ -3132,8 +3132,8 @@ export class ThreadSessionRuntime {
         const truncate = (s, max) => {
             return s.length > max ? s.slice(0, max - 1) + '\u2026' : s;
         };
-        const truncatedFolder = truncate(folderName, 15);
-        const truncatedBranch = truncate(branchName, 15);
+        const truncatedFolder = truncate(folderName, 30);
+        const truncatedBranch = truncate(branchName, 30);
         const projectInfo = truncatedBranch
             ? `${truncatedFolder} ⋅ ${truncatedBranch} ⋅ `
             : `${truncatedFolder} ⋅ `;

package/dist/system-prompt-drift-plugin.js

@@ -0,0 +1,243 @@
+// OpenCode plugin that detects per-session system prompt drift across turns.
+// When the effective system prompt changes after the first user message, it
+// writes a debug diff file and shows a toast because prompt-cache invalidation
+// increases rate-limit usage and usually means another plugin is mutating the
+// system prompt unexpectedly.
+import fs from 'node:fs';
+import path from 'node:path';
+import { createPatch, diffLines } from 'diff';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath } from './plugin-logger.js';
+import { initSentry, notifyError } from './sentry.js';
+import { abbreviatePath } from './utils.js';
+const logger = createPluginLogger('OPENCODE');
+function getSystemPromptDiffDir({ dataDir }) {
+    return path.join(dataDir, 'system-prompt-diffs');
+}
+function normalizeSystemPrompt({ system }) {
+    return system.join('\n');
+}
+function buildTurnContext({ input, directory, }) {
+    const model = input.model
+        ? `${input.model.providerID}/${input.model.modelID}${input.variant ? `:${input.variant}` : ''}`
+        : undefined;
+    return {
+        agent: input.agent,
+        model,
+        directory,
+    };
+}
+function shouldSuppressDiffNotice({ previousContext, currentContext, }) {
+    if (!previousContext || !currentContext) {
+        return false;
+    }
+    return (previousContext.agent !== currentContext.agent
+        || previousContext.model !== currentContext.model
+        || previousContext.directory !== currentContext.directory);
+}
+function buildPatch({ beforeText, afterText, beforeLabel, afterLabel, }) {
+    const changes = diffLines(beforeText, afterText);
+    const additions = changes.reduce((count, change) => {
+        if (!change.added) {
+            return count;
+        }
+        return count + change.count;
+    }, 0);
+    const deletions = changes.reduce((count, change) => {
+        if (!change.removed) {
+            return count;
+        }
+        return count + change.count;
+    }, 0);
+    const patch = createPatch(afterLabel, beforeText, afterText, beforeLabel, afterLabel);
+    return {
+        additions,
+        deletions,
+        patch,
+    };
+}
+function writeSystemPromptDiffFile({ dataDir, sessionId, beforePrompt, afterPrompt, }) {
+    const diff = buildPatch({
+        beforeText: beforePrompt,
+        afterText: afterPrompt,
+        beforeLabel: 'system-before.txt',
+        afterLabel: 'system-after.txt',
+    });
+    const timestamp = new Date().toISOString().replaceAll(':', '-');
+    const sessionDir = path.join(getSystemPromptDiffDir({ dataDir }), sessionId);
+    const filePath = path.join(sessionDir, `${timestamp}.diff`);
+    const latestPromptPath = path.join(sessionDir, `${sessionId}.md`);
+    const fileContent = [
+        `Session: ${sessionId}`,
+        `Created: ${new Date().toISOString()}`,
+        `Additions: ${diff.additions}`,
+        `Deletions: ${diff.deletions}`,
+        '',
+        diff.patch,
+    ].join('\n');
+    return errore.try({
+        try: () => {
+            fs.mkdirSync(sessionDir, { recursive: true });
+            fs.writeFileSync(filePath, fileContent);
+            // fs.writeFileSync(latestPromptPath, afterPrompt)
+            return {
+                additions: diff.additions,
+                deletions: diff.deletions,
+                filePath,
+            };
+        },
+        catch: (error) => {
+            return new Error('Failed to write system prompt diff file', { cause: error });
+        },
+    });
+}
+function getOrCreateSessionState({ sessions, sessionId, }) {
+    const existing = sessions.get(sessionId);
+    if (existing) {
+        return existing;
+    }
+    const state = {
+        userTurnCount: 0,
+        previousTurnPrompt: undefined,
+        latestTurnPrompt: undefined,
+        latestTurnPromptTurn: 0,
+        comparedTurn: 0,
+        previousTurnContext: undefined,
+        currentTurnContext: undefined,
+    };
+    sessions.set(sessionId, state);
+    return state;
+}
+async function handleSystemTransform({ input, output, sessions, dataDir, client, }) {
+    const sessionId = input.sessionID;
+    if (!sessionId) {
+        return;
+    }
+    const currentPrompt = normalizeSystemPrompt({ system: output.system });
+    const state = getOrCreateSessionState({
+        sessions,
+        sessionId,
+    });
+    const currentTurn = state.userTurnCount;
+    state.latestTurnPrompt = currentPrompt;
+    state.latestTurnPromptTurn = currentTurn;
+    if (currentTurn <= 1) {
+        return;
+    }
+    if (state.comparedTurn === currentTurn) {
+        return;
+    }
+    const previousPrompt = state.previousTurnPrompt;
+    state.comparedTurn = currentTurn;
+    if (!previousPrompt || previousPrompt === currentPrompt) {
+        return;
+    }
+    if (shouldSuppressDiffNotice({
+        previousContext: state.previousTurnContext,
+        currentContext: state.currentTurnContext,
+    })) {
+        return;
+    }
+    if (!dataDir) {
+        return;
+    }
+    const diffFileResult = writeSystemPromptDiffFile({
+        dataDir,
+        sessionId,
+        beforePrompt: previousPrompt,
+        afterPrompt: currentPrompt,
+    });
+    if (diffFileResult instanceof Error) {
+        throw diffFileResult;
+    }
+    await client.tui.showToast({
+        body: {
+            variant: 'info',
+            title: 'Context cache discarded',
+            message: `System prompt changed since the previous message (+${diffFileResult.additions} / -${diffFileResult.deletions}). ` +
+                `This usually means a plugin mutated the prompt and increased rate-limit usage. ` +
+                `Diff: ${abbreviatePath(diffFileResult.filePath)}`,
+        },
+    });
+}
+const systemPromptDriftPlugin = async ({ client, directory }) => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const sessions = new Map();
+    return {
+        'chat.message': async (input) => {
+            const sessionId = input.sessionID;
+            if (!sessionId) {
+                return;
+            }
+            const state = getOrCreateSessionState({ sessions, sessionId });
+            if (state.userTurnCount > 0
+                && state.latestTurnPromptTurn === state.userTurnCount) {
+                state.previousTurnPrompt = state.latestTurnPrompt;
+                state.previousTurnContext = state.currentTurnContext;
+            }
+            state.currentTurnContext = buildTurnContext({ input, directory });
+            state.userTurnCount += 1;
+        },
+        'experimental.chat.system.transform': async (input, output) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    await handleSystemTransform({
+                        input,
+                        output,
+                        sessions,
+                        dataDir,
+                        client,
+                    });
+                },
+                catch: (error) => {
+                    return new Error('system prompt drift transform hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (result instanceof Error) {
+                logger.warn(`[system-prompt-drift-plugin] ${formatPluginErrorWithStack(result)}`);
+                void notifyError(result, 'system prompt drift plugin transform hook failed');
+            }
+        },
+        event: async ({ event }) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    if (event.type !== 'session.deleted') {
+                        return;
+                    }
+                    const deletedSessionId = getDeletedSessionId({ event });
+                    if (!deletedSessionId) {
+                        return;
+                    }
+                    sessions.delete(deletedSessionId);
+                },
+                catch: (error) => {
+                    return new Error('system prompt drift event hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (result instanceof Error) {
+                logger.warn(`[system-prompt-drift-plugin] ${formatPluginErrorWithStack(result)}`);
+                void notifyError(result, 'system prompt drift plugin event hook failed');
+            }
+        },
+    };
+};
+function getDeletedSessionId({ event }) {
+    if (event.type !== 'session.deleted') {
+        return undefined;
+    }
+    const sessionInfo = event.properties?.info;
+    if (!sessionInfo || typeof sessionInfo !== 'object') {
+        return undefined;
+    }
+    const id = 'id' in sessionInfo ? sessionInfo.id : undefined;
+    return typeof id === 'string' ? id : undefined;
+}
+export { systemPromptDriftPlugin };

package/dist/system-prompt-drift-plugin.test.js

@@ -0,0 +1,158 @@
+// Tests for system prompt drift detection in the OpenCode plugin hook.
+import fs from 'node:fs';
+import path from 'node:path';
+import { afterEach, describe, expect, test } from 'vitest';
+import { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
+function createContext({ client }) {
+    return {
+        client: client,
+        project: {
+            id: 'project-id',
+            worktree: '/Users/morse/Documents/GitHub/kimakivoice',
+            time: { created: Date.now() },
+        },
+        directory: '/Users/morse/Documents/GitHub/kimakivoice',
+        worktree: '/Users/morse/Documents/GitHub/kimakivoice',
+        serverUrl: new URL('http://127.0.0.1:4096'),
+        $: {},
+    };
+}
+function createTransformOutput({ system, }) {
+    return { system };
+}
+async function requireHooks({ client, }) {
+    const hooks = await systemPromptDriftPlugin(createContext({ client }));
+    const transformHook = hooks['experimental.chat.system.transform'];
+    if (!transformHook) {
+        throw new Error('Expected experimental.chat.system.transform hook');
+    }
+    const eventHook = hooks.event;
+    if (!eventHook) {
+        throw new Error('Expected event hook');
+    }
+    return { transformHook, eventHook };
+}
+function createSessionDeletedEvent({ sessionId }) {
+    return {
+        type: 'session.deleted',
+        properties: {
+            info: { id: sessionId },
+        },
+    };
+}
+const createdPaths = [];
+afterEach(() => {
+    delete process.env.KIMAKI_DATA_DIR;
+    for (const createdPath of createdPaths.splice(0)) {
+        fs.rmSync(createdPath, { recursive: true, force: true });
+    }
+});
+describe('systemPromptDriftPlugin', () => {
+    test('first prompt only stores baseline and shows no toast', async () => {
+        const toastCalls = [];
+        const client = {
+            tui: {
+                showToast: async (input) => {
+                    toastCalls.push(input);
+                },
+            },
+        };
+        const tmpRoot = path.join(process.cwd(), 'tmp', 'system-prompt-drift-first');
+        createdPaths.push(tmpRoot);
+        fs.mkdirSync(tmpRoot, { recursive: true });
+        process.env.KIMAKI_DATA_DIR = tmpRoot;
+        const { transformHook } = await requireHooks({ client });
+        await transformHook({
+            sessionID: 'ses-first',
+            model: { id: 'model-id', name: 'Model', providerID: 'provider-id' },
+        }, createTransformOutput({ system: ['alpha', 'beta'] }));
+        expect(toastCalls).toMatchInlineSnapshot('[]');
+        expect(fs.existsSync(path.join(tmpRoot, 'system-prompt-diffs', 'ses-first'))).toBe(false);
+    });
+    test('changed prompt writes diff file and shows toast with counts', async () => {
+        const toastCalls = [];
+        const client = {
+            tui: {
+                showToast: async (input) => {
+                    toastCalls.push(input);
+                },
+            },
+        };
+        const tmpRoot = path.join(process.cwd(), 'tmp', 'system-prompt-drift-changed');
+        createdPaths.push(tmpRoot);
+        fs.mkdirSync(tmpRoot, { recursive: true });
+        process.env.KIMAKI_DATA_DIR = tmpRoot;
+        const { transformHook } = await requireHooks({ client });
+        const input = {
+            sessionID: 'ses-changed',
+            model: { id: 'model-id', name: 'Model', providerID: 'provider-id' },
+        };
+        await transformHook(input, createTransformOutput({ system: ['line-1', 'line-2'] }));
+        await transformHook(input, createTransformOutput({ system: ['line-1', 'line-2-updated', 'line-3'] }));
+        const diffDir = path.join(tmpRoot, 'system-prompt-diffs', 'ses-changed');
+        const diffFiles = fs.readdirSync(diffDir);
+        const diffPath = path.join(diffDir, diffFiles[0] || '');
+        const diffContent = fs.readFileSync(diffPath, 'utf-8');
+        expect(toastCalls).toHaveLength(1);
+        const sanitizedToastCall = {
+            body: {
+                ...toastCalls[0].body,
+                message: toastCalls[0].body.message.replace(diffPath, '<diff-path>'),
+            },
+        };
+        expect(sanitizedToastCall).toMatchInlineSnapshot(`
+      {
+        "body": {
+          "message": "The system prompt changed since the previous message (+2 / -1). This discards context cache and increases rate limits. This usually means a plugin is mutating the system prompt. Diff: <diff-path>",
+          "title": "System prompt changed",
+          "variant": "error",
+        },
+      }
+    `);
+        expect(diffFiles.length).toBe(1);
+        expect(diffContent.replace(/Created: .*\n/u, 'Created: <timestamp>\n')).toMatchInlineSnapshot(`
+      "Session: ses-changed
+      Created: <timestamp>
+      Additions: 2
+      Deletions: 1
+
+      Index: system-after.txt
+      ===================================================================
+      --- system-after.txt\tsystem-before.txt
+      +++ system-after.txt\tsystem-after.txt
+      @@ -1,2 +1,3 @@
+       line-1
+      -line-2
+      \
+      +line-2-updated
+      +line-3
+      \
+      "
+    `);
+    });
+    test('session.deleted clears baseline so next turn becomes first turn again', async () => {
+        const toastCalls = [];
+        const client = {
+            tui: {
+                showToast: async (input) => {
+                    toastCalls.push(input);
+                },
+            },
+        };
+        const tmpRoot = path.join(process.cwd(), 'tmp', 'system-prompt-drift-deleted');
+        createdPaths.push(tmpRoot);
+        fs.mkdirSync(tmpRoot, { recursive: true });
+        process.env.KIMAKI_DATA_DIR = tmpRoot;
+        const { transformHook, eventHook } = await requireHooks({ client });
+        const input = {
+            sessionID: 'ses-deleted',
+            model: { id: 'model-id', name: 'Model', providerID: 'provider-id' },
+        };
+        await transformHook(input, createTransformOutput({ system: ['first'] }));
+        await eventHook({ event: createSessionDeletedEvent({ sessionId: 'ses-deleted' }) });
+        await transformHook(input, createTransformOutput({ system: ['second'] }));
+        expect(toastCalls).toMatchInlineSnapshot('[]');
+        const diffSessionDir = path.join(tmpRoot, 'system-prompt-diffs', 'ses-deleted');
+        expect(fs.existsSync(diffSessionDir)).toBe(false);
+    });
+});