@otto-assistant/bridge 0.4.97 → 0.4.101

package/dist/cli-send-thread.e2e.test.js

@@ -257,14 +257,11 @@ describe('kimaki send --channel thread creation', () => {
                 return m.author.id === discord.botUserId && m.id !== starterMessage.id;
             });
             const allContent = botReplies.map((m) => {
-                return m.content.slice(0, 200);
+                return m.content;
             });
-            expect(allContent).toMatchInlineSnapshot(`
-          [
-            "✗ opencode session error: Command not found: "hello-test". Available commands: init, review, goke, security-review, jitter, proxyman, gitchamber, event-sourcing-state, usecomputer, spiceflow, batch, x",
-            "✗ OpenCode API error: Command not found: "hello-test". Available commands: init, review, goke, security-review, jitter, proxyman, gitchamber, event-sourcing-state, usecomputer, spiceflow, batch, x-art",
-          ]
-        `);
+            expect(allContent.some((content) => {
+                return content.includes('Command not found: "hello-test"');
+            })).toBe(true);
         }
         finally {
             store.setState({ registeredUserCommands: prevCommands });

package/dist/cli.js

@@ -41,7 +41,7 @@ const cliLogger = createLogger(LogPrefix.CLI);
 // We derive REST base from this URL by swapping ws/wss to http/https.
 // These are hardcoded because they're deploy-time constants for the gateway infrastructure.
 const KIMAKI_GATEWAY_PROXY_URL = process.env.KIMAKI_GATEWAY_PROXY_URL ||
-    'wss://discord-gateway.kimaki.xyz';
+    'wss://discord-gateway.kimaki.dev';
 const KIMAKI_GATEWAY_PROXY_REST_BASE_URL = getGatewayProxyRestBaseUrl({
     gatewayUrl: KIMAKI_GATEWAY_PROXY_URL,
 });
@@ -2695,7 +2695,7 @@ cli
         port,
         tunnelId: options.tunnelId,
         localHost: options.host,
-        baseDomain: 'kimaki.xyz',
+        baseDomain: 'kimaki.dev',
         serverUrl: options.server,
         command: command.length > 0 ? command : undefined,
         kill: options.kill,

package/dist/commands/login.js

@@ -39,6 +39,8 @@ const PROVIDER_POPULARITY_ORDER = [
     'xai',
     'groq',
     'deepseek',
+    'opencode',
+    'opencode-go',
     'mistral',
     'openrouter',
     'fireworks-ai',
@@ -47,12 +49,12 @@ const PROVIDER_POPULARITY_ORDER = [
     'azure',
     'google-vertex',
     'google-vertex-anthropic',
-    'cohere',
+    // 'cohere',
     'cerebras',
-    'perplexity',
+    // 'perplexity',
     'cloudflare-workers-ai',
-    'novita-ai',
-    'huggingface',
+    // 'novita-ai',
+    // 'huggingface',
     'deepinfra',
     'github-models',
     'lmstudio',

package/dist/commands/screenshare.js

@@ -21,7 +21,7 @@ const activeSessions = new Map();
 const VNC_PORT = 5900;
 const MAX_SESSION_MINUTES = 30;
 const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
-const TUNNEL_BASE_DOMAIN = 'kimaki.xyz';
+const TUNNEL_BASE_DOMAIN = 'kimaki.dev';
 const SCREENSHARE_TUNNEL_ID_BYTES = 16;
 // Public noVNC client — we point it at our tunnel URL
 export function buildNoVncUrl({ tunnelHost }) {

package/dist/commands/screenshare.test.js

@@ -11,9 +11,9 @@ describe('screenshare security defaults', () => {
         }
     });
     test('builds a secure noVNC URL', () => {
-        const url = new URL(buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.xyz' }));
+        const url = new URL(buildNoVncUrl({ tunnelHost: '0123456789abcdef-tunnel.kimaki.dev' }));
         expect(url.origin).toBe('https://novnc.com');
-        expect(url.searchParams.get('host')).toBe('0123456789abcdef-tunnel.kimaki.xyz');
+        expect(url.searchParams.get('host')).toBe('0123456789abcdef-tunnel.kimaki.dev');
         expect(url.searchParams.get('port')).toBe('443');
         expect(url.searchParams.get('encrypt')).toBe('1');
     });

package/dist/commands/vscode.js

@@ -0,0 +1,269 @@
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import { ChannelType, MessageFlags, } from 'discord.js';
+import { TunnelClient } from 'traforo/client';
+import { resolveWorkingDirectory, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('VSCODE');
+const SECURE_REPLY_FLAGS = MessageFlags.Ephemeral | SILENT_MESSAGE_FLAGS;
+const MAX_SESSION_MINUTES = 30;
+const MAX_SESSION_MS = MAX_SESSION_MINUTES * 60 * 1000;
+const TUNNEL_BASE_DOMAIN = 'kimaki.dev';
+const TUNNEL_ID_BYTES = 16;
+const READY_TIMEOUT_MS = 60_000;
+const LOCAL_HOST = '127.0.0.1';
+const activeSessions = new Map();
+export function createVscodeTunnelId() {
+    return crypto.randomBytes(TUNNEL_ID_BYTES).toString('hex');
+}
+export function buildCoderaftArgs({ port, workingDirectory, }) {
+    return [
+        'coderaft',
+        '--port',
+        String(port),
+        '--host',
+        LOCAL_HOST,
+        '--without-connection-token',
+        '--disable-workspace-trust',
+        '--default-folder',
+        workingDirectory,
+    ];
+}
+function createPortWaiter({ port, process: proc, timeoutMs, }) {
+    return new Promise((resolve, reject) => {
+        const maxAttempts = Math.ceil(timeoutMs / 100);
+        let attempts = 0;
+        const check = () => {
+            if (proc.exitCode !== null) {
+                reject(new Error(`coderaft exited with code ${proc.exitCode} before becoming ready`));
+                return;
+            }
+            const socket = net.createConnection(port, LOCAL_HOST);
+            socket.on('connect', () => {
+                socket.destroy();
+                resolve();
+            });
+            socket.on('error', () => {
+                socket.destroy();
+                attempts += 1;
+                if (attempts >= maxAttempts) {
+                    reject(new Error(`Port ${port} not reachable after ${timeoutMs}ms`));
+                    return;
+                }
+                setTimeout(check, 100);
+            });
+        };
+        check();
+    });
+}
+function getAvailablePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.on('error', reject);
+        server.listen(0, LOCAL_HOST, () => {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                server.close(() => {
+                    reject(new Error('Failed to resolve an available port'));
+                });
+                return;
+            }
+            const port = address.port;
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(port);
+            });
+        });
+    });
+}
+function cleanupSession(session) {
+    clearTimeout(session.timeoutTimer);
+    try {
+        session.tunnelClient.close();
+    }
+    catch { }
+    if (session.coderaftProcess.exitCode === null) {
+        try {
+            session.coderaftProcess.kill('SIGTERM');
+        }
+        catch { }
+    }
+}
+export function getActiveVscodeSession({ sessionKey }) {
+    return activeSessions.get(sessionKey);
+}
+export function stopVscode({ sessionKey }) {
+    const session = activeSessions.get(sessionKey);
+    if (!session) {
+        return false;
+    }
+    activeSessions.delete(sessionKey);
+    cleanupSession(session);
+    logger.log(`VS Code stopped (key: ${sessionKey})`);
+    return true;
+}
+export async function startVscode({ sessionKey, startedBy, workingDirectory, }) {
+    const existing = activeSessions.get(sessionKey);
+    if (existing) {
+        return existing;
+    }
+    const port = await getAvailablePort();
+    const tunnelId = createVscodeTunnelId();
+    const args = buildCoderaftArgs({
+        port,
+        workingDirectory,
+    });
+    const coderaftProcess = spawn('bunx', args, {
+        cwd: workingDirectory,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            PORT: String(port),
+        },
+    });
+    coderaftProcess.stdout?.on('data', (data) => {
+        logger.log(data.toString().trim());
+    });
+    coderaftProcess.stderr?.on('data', (data) => {
+        logger.error(data.toString().trim());
+    });
+    try {
+        await createPortWaiter({
+            port,
+            process: coderaftProcess,
+            timeoutMs: READY_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        if (coderaftProcess.exitCode === null) {
+            coderaftProcess.kill('SIGTERM');
+        }
+        throw error;
+    }
+    const tunnelClient = new TunnelClient({
+        localPort: port,
+        localHost: LOCAL_HOST,
+        tunnelId,
+        baseDomain: TUNNEL_BASE_DOMAIN,
+    });
+    try {
+        await Promise.race([
+            tunnelClient.connect(),
+            new Promise((_, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Tunnel connection timed out after 15s'));
+                }, 15_000);
+            }),
+        ]);
+    }
+    catch (error) {
+        tunnelClient.close();
+        if (coderaftProcess.exitCode === null) {
+            coderaftProcess.kill('SIGTERM');
+        }
+        throw error;
+    }
+    const url = tunnelClient.url;
+    const timeoutTimer = setTimeout(() => {
+        logger.log(`VS Code auto-stopped after ${MAX_SESSION_MINUTES} minutes (key: ${sessionKey})`);
+        stopVscode({ sessionKey });
+    }, MAX_SESSION_MS);
+    timeoutTimer.unref();
+    const session = {
+        coderaftProcess,
+        tunnelClient,
+        url,
+        workingDirectory,
+        startedBy,
+        startedAt: Date.now(),
+        timeoutTimer,
+    };
+    coderaftProcess.once('exit', (code, signal) => {
+        const current = activeSessions.get(sessionKey);
+        if (current !== session) {
+            return;
+        }
+        logger.log(`VS Code process exited (key: ${sessionKey}, code: ${code}, signal: ${signal ?? 'none'})`);
+        stopVscode({ sessionKey });
+    });
+    activeSessions.set(sessionKey, session);
+    logger.log(`VS Code started by ${startedBy}: ${url}`);
+    return session;
+}
+export async function handleVscodeCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    const isTextChannel = channel.type === ChannelType.GuildText;
+    if (!isThread && !isTextChannel) {
+        await command.reply({
+            content: 'This command can only be used in a text channel or thread.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    const resolved = await resolveWorkingDirectory({
+        channel: channel,
+    });
+    if (!resolved) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel.',
+            flags: SECURE_REPLY_FLAGS,
+        });
+        return;
+    }
+    await command.deferReply({ flags: SECURE_REPLY_FLAGS });
+    const sessionKey = channel.id;
+    const existing = getActiveVscodeSession({ sessionKey });
+    if (existing) {
+        await command.editReply({
+            content: `VS Code is already running for this thread. ` +
+                `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes from startup.\n` +
+                `${existing.url}`,
+        });
+        return;
+    }
+    try {
+        const session = await startVscode({
+            sessionKey,
+            startedBy: command.user.tag,
+            workingDirectory: resolved.workingDirectory,
+        });
+        await command.editReply({
+            content: `VS Code started for \`${session.workingDirectory}\`. ` +
+                `This unique tunnel auto-stops after ${MAX_SESSION_MINUTES} minutes, so open it before it expires.\n` +
+                `${session.url}`,
+        });
+    }
+    catch (error) {
+        logger.error('Failed to start VS Code:', error);
+        await command.editReply({
+            content: `Failed to start VS Code: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+export function cleanupAllVscodeSessions() {
+    for (const sessionKey of activeSessions.keys()) {
+        stopVscode({ sessionKey });
+    }
+}
+function onProcessExit() {
+    cleanupAllVscodeSessions();
+}
+process.on('SIGINT', onProcessExit);
+process.on('SIGTERM', onProcessExit);
+process.on('exit', onProcessExit);

package/dist/context-awareness-plugin.js

@@ -1,7 +1,6 @@
 // OpenCode plugin that injects synthetic message parts for context awareness:
 // - Git branch / detached HEAD changes
 // - Working directory (pwd) changes (e.g. after /new-worktree mid-session)
-// - MEMORY.md table of contents on first message
 // - MEMORY.md reminder after a large assistant reply
 // - Onboarding tutorial instructions (when TUTORIAL_WELCOME_TEXT detected)
 //
@@ -16,26 +15,13 @@
 // Exported from kimaki-opencode-plugin.ts — each export is treated as a separate
 // plugin by OpenCode's plugin loader.
 import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
 import * as errore from 'errore';
 import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
 import { setDataDir } from './config.js';
 import { initSentry, notifyError } from './sentry.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 = createPluginLogger('OPENCODE');
-function createSessionState() {
-    return {
-        gitState: undefined,
-        memoryInjected: false,
-        lastMemoryReminderAssistantMessageId: undefined,
-        tutorialInjected: false,
-        resolvedDirectory: undefined,
-        announcedDirectory: undefined,
-    };
-}
 // ── Pure derivation functions ────────────────────────────────────
 // These take state + fresh input and return whether to inject.
 // No side effects, no mutations — easy to test with fixtures.
@@ -66,9 +52,6 @@ export function shouldInjectPwd({ currentDir, previousDir, announcedDir, }) {
     };
 }
 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 };
@@ -85,7 +68,7 @@ export function shouldInjectMemoryReminderFromLatestAssistant({ lastMemoryRemind
     if (lastMemoryReminderAssistantMessageId === latestAssistantMessage.id) {
         return { inject: false };
     }
-    const outputTokens = getOutputTokenTotal(latestAssistantMessage.tokens);
+    const outputTokens = Math.max(0, latestAssistantMessage.tokens.output + latestAssistantMessage.tokens.reasoning);
     if (outputTokens < threshold) {
         return { inject: false };
     }
@@ -184,7 +167,13 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
         if (existing) {
             return existing;
         }
-        const state = createSessionState();
+        const state = {
+            gitState: undefined,
+            lastMemoryReminderAssistantMessageId: undefined,
+            tutorialInjected: false,
+            resolvedDirectory: undefined,
+            announcedDirectory: undefined,
+        };
         sessions.set(sessionID, state);
         return state;
     }
@@ -274,25 +263,6 @@ const contextAwarenessPlugin = async ({ directory, client }) => {
                             synthetic: true,
                         });
                     }
-                    // -- MEMORY.md injection --
-                    if (!state.memoryInjected) {
-                        state.memoryInjected = true;
-                        const memoryPath = path.join(effectiveDirectory, 'MEMORY.md');
-                        const memoryContent = await fs.promises
-                            .readFile(memoryPath, 'utf-8')
-                            .catch(() => null);
-                        if (memoryContent) {
-                            const condensed = condenseMemoryMd(memoryContent);
-                            output.parts.push({
-                                id: `prt_${crypto.randomUUID()}`,
-                                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, 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,
-                            });
-                        }
-                    }
                     const memoryReminder = shouldInjectMemoryReminderFromLatestAssistant({
                         lastMemoryReminderAssistantMessageId: state.lastMemoryReminderAssistantMessageId,
                         latestAssistantMessage,

package/dist/db.js

@@ -201,6 +201,7 @@ async function migrateSchema(prisma) {
     // Also fix NULL worktree status rows that predate the required enum.
     const defensiveMigrations = [
         "UPDATE bot_tokens SET bot_mode = 'self_hosted' WHERE bot_mode = 'self-hosted'",
+        "UPDATE bot_tokens SET proxy_url = REPLACE(proxy_url, 'discord-gateway.kimaki.xyz', 'discord-gateway.kimaki.dev') WHERE bot_mode = 'gateway' AND proxy_url LIKE '%discord-gateway.kimaki.xyz%'",
         "UPDATE thread_worktrees SET status = 'pending' WHERE status IS NULL",
     ];
     for (const stmt of defensiveMigrations) {

package/dist/discord-command-registration.js

@@ -365,6 +365,11 @@ export async function registerCommands({ token, appId, guildIds, userCommands =
             .setDescription(truncateCommandDescription('Stop screen sharing'))
             .setDMPermission(false)
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('vscode')
+            .setDescription(truncateCommandDescription('Open VS Code in the browser for this project or worktree (auto-stops after 30 minutes)'))
+            .setDMPermission(false)
+            .toJSON(),
     ];
     // Dynamic commands are registered in priority order: agents → user commands → skills → MCP prompts.
     // This ordering matters because we slice to MAX_DISCORD_COMMANDS (100) at the end,

package/dist/gateway-proxy-reconnect.e2e.test.js

@@ -6,7 +6,7 @@
 //   Starts a digital-twin + local gateway-proxy binary, kills and restarts the proxy.
 //
 // Production mode (env vars):
-//   GATEWAY_TEST_URL        - production gateway WS+REST URL (e.g. wss://discord-gateway.kimaki.xyz)
+//   GATEWAY_TEST_URL        - production gateway WS+REST URL (e.g. wss://discord-gateway.kimaki.dev)
 //   GATEWAY_TEST_TOKEN      - client token (clientId:secret)
 //   GATEWAY_TEST_REDEPLOY   - if "1", runs `fly deploy` between kill/restart instead of local binary
 //
@@ -15,7 +15,7 @@
 //   pnpm test --run src/gateway-proxy-reconnect.e2e.test.ts
 //
 //   # Against production (just connect + kill WS + wait for reconnect):
-//   GATEWAY_TEST_URL=wss://discord-gateway.kimaki.xyz \
+//   GATEWAY_TEST_URL=wss://discord-gateway.kimaki.dev \
 //   GATEWAY_TEST_TOKEN=myclientid:mysecret \
 //   KIMAKI_TEST_LOGS=1 \
 //   pnpm test --run src/gateway-proxy-reconnect.e2e.test.ts -t "production"

package/dist/interaction-handler.js

@@ -39,6 +39,7 @@ import { handleSessionIdCommand } from './commands/session-id.js';
 import { handleUpgradeAndRestartCommand } from './commands/upgrade.js';
 import { handleMcpCommand, handleMcpSelectMenu } from './commands/mcp.js';
 import { handleScreenshareCommand, handleScreenshareStopCommand, } from './commands/screenshare.js';
+import { handleVscodeCommand } from './commands/vscode.js';
 import { handleModelVariantSelectMenu } from './commands/model.js';
 import { handleModelVariantCommand, handleVariantQuickSelectMenu, handleVariantScopeSelectMenu, } from './commands/model-variant.js';
 import { hasKimakiBotPermission } from './discord-utils.js';
@@ -224,6 +225,9 @@ export function registerInteractionHandler({ discordClient, appId, }) {
                             appId,
                         });
                         return;
+                    case 'vscode':
+                        await handleVscodeCommand({ command: interaction, appId });
+                        return;
                 }
                 // Handle quick agent commands (ending with -agent suffix, but not the base /agent command)
                 if (interaction.commandName.endsWith('-agent') &&

package/dist/kimaki-opencode-plugin.js

@@ -5,11 +5,13 @@
 //
 // Plugins are split into focused modules:
 // - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
-// - context-awareness-plugin: branch, pwd, memory, time gap, onboarding tutorial
+// - context-awareness-plugin: branch, pwd, memory reminder, onboarding tutorial
+// - memory-overview-plugin: frozen MEMORY.md heading overview per session
 // - opencode-interrupt-plugin: interrupt queued messages at step boundaries
 // - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
 export { ipcToolsPlugin } from './ipc-tools-plugin.js';
 export { contextAwarenessPlugin } from './context-awareness-plugin.js';
+export { memoryOverviewPlugin } from './memory-overview-plugin.js';
 export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js';
 export { systemPromptDriftPlugin } from './system-prompt-drift-plugin.js';
 export { anthropicAuthPlugin } from './anthropic-auth-plugin.js';

package/dist/memory-overview-plugin.js

@@ -0,0 +1,126 @@
+// OpenCode plugin that snapshots the MEMORY.md heading overview once per
+// session and injects that frozen snapshot on the first real user message.
+// The snapshot is cached by session ID so later MEMORY.md edits do not change
+// the prompt for the same session and do not invalidate OpenCode's cache.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as errore from 'errore';
+import { createPluginLogger, formatPluginErrorWithStack, setPluginLogFilePath, } from './plugin-logger.js';
+import { condenseMemoryMd } from './condense-memory.js';
+import { initSentry, notifyError } from './sentry.js';
+const logger = createPluginLogger('OPENCODE');
+function createSessionState() {
+    return {
+        hasFrozenOverview: false,
+        frozenOverviewText: null,
+        injected: false,
+    };
+}
+function buildMemoryOverviewReminder({ condensed }) {
+    return `<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>`;
+}
+async function freezeMemoryOverview({ directory, state, }) {
+    if (state.hasFrozenOverview) {
+        return state.frozenOverviewText;
+    }
+    const memoryPath = path.join(directory, 'MEMORY.md');
+    const memoryContentResult = await fs.promises.readFile(memoryPath, 'utf-8').catch(() => {
+        return null;
+    });
+    if (!memoryContentResult) {
+        state.hasFrozenOverview = true;
+        state.frozenOverviewText = null;
+        return null;
+    }
+    const condensed = condenseMemoryMd(memoryContentResult);
+    state.hasFrozenOverview = true;
+    state.frozenOverviewText = buildMemoryOverviewReminder({ condensed });
+    return state.frozenOverviewText;
+}
+const memoryOverviewPlugin = async ({ directory }) => {
+    initSentry();
+    const dataDir = process.env.KIMAKI_DATA_DIR;
+    if (dataDir) {
+        setPluginLogFilePath(dataDir);
+    }
+    const sessions = new Map();
+    function getOrCreateSessionState({ sessionID }) {
+        const existing = sessions.get(sessionID);
+        if (existing) {
+            return existing;
+        }
+        const state = createSessionState();
+        sessions.set(sessionID, state);
+        return state;
+    }
+    return {
+        'chat.message': async (input, output) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    const state = getOrCreateSessionState({ sessionID: input.sessionID });
+                    if (state.injected) {
+                        return;
+                    }
+                    const firstPart = output.parts.find((part) => {
+                        if (part.type !== 'text') {
+                            return true;
+                        }
+                        return part.synthetic !== true;
+                    });
+                    if (!firstPart || firstPart.type !== 'text' || firstPart.text.trim().length === 0) {
+                        return;
+                    }
+                    const overviewText = await freezeMemoryOverview({ directory, state });
+                    state.injected = true;
+                    if (!overviewText) {
+                        return;
+                    }
+                    output.parts.push({
+                        id: `prt_${crypto.randomUUID()}`,
+                        sessionID: input.sessionID,
+                        messageID: firstPart.messageID,
+                        type: 'text',
+                        text: overviewText,
+                        synthetic: true,
+                    });
+                },
+                catch: (error) => {
+                    return new Error('memory overview chat.message hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (!(result instanceof Error)) {
+                return;
+            }
+            logger.warn(`[memory-overview-plugin] ${formatPluginErrorWithStack(result)}`);
+            void notifyError(result, 'memory overview plugin chat.message hook failed');
+        },
+        event: async ({ event }) => {
+            const result = await errore.tryAsync({
+                try: async () => {
+                    if (event.type !== 'session.deleted') {
+                        return;
+                    }
+                    const id = event.properties?.info?.id;
+                    if (!id) {
+                        return;
+                    }
+                    sessions.delete(id);
+                },
+                catch: (error) => {
+                    return new Error('memory overview event hook failed', {
+                        cause: error,
+                    });
+                },
+            });
+            if (!(result instanceof Error)) {
+                return;
+            }
+            logger.warn(`[memory-overview-plugin] ${formatPluginErrorWithStack(result)}`);
+            void notifyError(result, 'memory overview plugin event hook failed');
+        },
+    };
+};
+export { memoryOverviewPlugin };