@otto-assistant/bridge 0.4.97 → 0.4.100

package/dist/system-message.test.js

@@ -16,7 +16,7 @@ describe('system-message', () => {
             ],
         }).replace(/`[^`]*\/kimaki\.log`/, '`<data-dir>/kimaki.log`')).toMatchInlineSnapshot(`
       "
-      The user is reading your messages from inside Discord, via kimaki.xyz
+      The user is reading your messages from inside Discord, via kimaki.dev
 
       ## bash tool
 
@@ -85,39 +85,40 @@ describe('system-message', () => {
 
       To start a new thread/session in this channel pro-grammatically, run:
 
-      kimaki send --channel chan_123 --prompt "your prompt here" --user "Tommy"
+      kimaki send --channel chan_123 --prompt "your prompt here" --agent <current_agent> --user "Tommy"
 
       You can use this to "spawn" parallel helper sessions like teammates: start new threads with focused prompts, then come back and collect the results.
+      Prefer passing the current agent with \`--agent <current_agent>\` so spawned or scheduled sessions keep the same agent unless you are intentionally switching. Replace \`<current_agent>\` with the value from the per-turn \`Current agent\` reminder.
 
       IMPORTANT: NEVER use \`--worktree\` unless the user explicitly asks for a worktree. Default to creating normal threads without worktrees.
 
       To send a prompt to an existing thread instead of creating a new one:
 
-      kimaki send --thread <thread_id> --prompt "follow-up prompt"
+      kimaki send --thread <thread_id> --prompt "follow-up prompt" --agent <current_agent>
 
       Use this when you already have the Discord thread ID.
 
       To send to the thread associated with a known session:
 
-      kimaki send --session <session_id> --prompt "follow-up prompt"
+      kimaki send --session <session_id> --prompt "follow-up prompt" --agent <current_agent>
 
       Use this when you have the OpenCode session ID.
 
       Use --notify-only to create a notification thread without starting an AI session:
 
-      kimaki send --channel chan_123 --prompt "User cancelled subscription" --notify-only --user "Tommy"
+      kimaki send --channel chan_123 --prompt "User cancelled subscription" --notify-only --agent <current_agent> --user "Tommy"
 
       Use --user to add a specific Discord user to the new thread:
 
-      kimaki send --channel chan_123 --prompt "Review the latest CI failure" --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Review the latest CI failure" --agent <current_agent> --user "Tommy"
 
       Use --worktree to create a git worktree for the session (ONLY when the user explicitly asks for a worktree):
 
-      kimaki send --channel chan_123 --prompt "Add dark mode support" --worktree dark-mode --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Add dark mode support" --worktree dark-mode --agent <current_agent> --user "Tommy"
 
       Use --cwd to start a session in an existing git worktree directory (must be a worktree of the project):
 
-      kimaki send --channel chan_123 --prompt "Continue work on feature" --cwd /path/to/existing-worktree --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Continue work on feature" --cwd /path/to/existing-worktree --agent <current_agent> --user "Tommy"
 
       Important:
       - NEVER use \`--worktree\` unless the user explicitly requests a worktree. Most tasks should use normal threads without worktrees.
@@ -139,8 +140,8 @@ describe('system-message', () => {
 
       You can trigger registered opencode commands (slash commands, skills, MCP prompts) by starting the \`--prompt\` with \`/commandname\`:
 
-      kimaki send --thread <thread_id> --prompt "/review fix the auth module"
-      kimaki send --channel chan_123 --prompt "/build-cmd update dependencies" --user "Tommy"
+      kimaki send --thread <thread_id> --prompt "/review fix the auth module" --agent <current_agent>
+      kimaki send --channel chan_123 --prompt "/build-cmd update dependencies" --agent <current_agent> --user "Tommy"
 
       The command name must match a registered opencode command. If the command is not recognized, the prompt is sent as plain text to the model. This works for both new threads (\`--channel\`) and existing threads (\`--thread\`/\`--session\`).
 
@@ -150,14 +151,14 @@ describe('system-message', () => {
 
       You can also switch agents via \`kimaki send\`:
 
-      kimaki send --thread <thread_id> --prompt "/<agentname>-agent"
+      kimaki send --thread <thread_id> --prompt "/<agentname>-agent" --agent <current_agent>
 
       ## scheduled sends and task management
 
       Use \`--send-at\` to schedule a one-time or recurring task:
 
-      kimaki send --channel chan_123 --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z" --user "Tommy"
-      kimaki send --channel chan_123 --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1" --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z" --agent <current_agent> --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1" --agent <current_agent> --user "Tommy"
 
       ALL scheduling is in UTC. Dates must be UTC ISO format ending with \`Z\`. Cron expressions also fire in UTC (e.g. \`0 9 * * 1\` means 9:00 UTC every Monday).
       When the user specifies a time without a timezone, ask them to confirm their timezone or the UTC equivalent. Never guess the user's timezone.
@@ -191,13 +192,13 @@ describe('system-message', () => {
 
       Use case patterns:
       - Reminder flows: create deadline reminders in this channel with one-time \`--send-at\`; mention only if action is required.
-      - Proactive reminders: when you encounter time-sensitive information during your work (e.g. creating an API key that expires in 90 days, a certificate with an expiration date, a trial period ending, a deadline mentioned in code comments), proactively schedule a \`--notify-only\` reminder before the expiration so the user gets notified in time. For example, if you generate an API key expiring on 2026-06-01, schedule a reminder a few days before: \`kimaki send --channel chan_123 --prompt "Reminder: <@USER_ID> the API key created on 2026-03-01 expires on 2026-06-01. Renew it before it breaks production." --send-at "2026-05-28T09:00:00Z" --notify-only\`. Always tell the user you scheduled the reminder so they know.
+      - Proactive reminders: when you encounter time-sensitive information during your work (e.g. creating an API key that expires in 90 days, a certificate with an expiration date, a trial period ending, a deadline mentioned in code comments), proactively schedule a \`--notify-only\` reminder before the expiration so the user gets notified in time. For example, if you generate an API key expiring on 2026-06-01, schedule a reminder a few days before: \`kimaki send --channel chan_123 --prompt "Reminder: <@USER_ID> the API key created on 2026-03-01 expires on 2026-06-01. Renew it before it breaks production." --send-at "2026-05-28T09:00:00Z" --notify-only --agent <current_agent>\`. Always tell the user you scheduled the reminder so they know.
       - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention @username only when failures require review".
       - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
       - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
       - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
 
-      kimaki send --session ses_123 --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only
+      kimaki send --session ses_123 --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only --agent <current_agent>
 
       Replace \`<future_UTC_time>\` with the computed UTC ISO timestamp. The \`--notify-only\` flag creates just a notification message without starting a new AI session. The \`<@userId>\` mention ensures the user gets a Discord notification.
 
@@ -212,7 +213,7 @@ describe('system-message', () => {
       When the user asks to "create a worktree" or "make a worktree", they mean you should use the kimaki CLI to create it. Do NOT use raw \`git worktree add\` commands. Instead use:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt "your task description" --worktree worktree-name --user "Tommy"
+      kimaki send --channel chan_123 --prompt "your task description" --worktree worktree-name --agent <current_agent> --user "Tommy"
       \`\`\`
 
       This creates a new Discord thread with an isolated git worktree and starts a session in it. The worktree name should be kebab-case and descriptive of the task.
@@ -228,7 +229,7 @@ describe('system-message', () => {
       Use \`--cwd\` to start a session in an existing git worktree directory instead of creating a new one:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt "Continue work on feature X" --cwd /path/to/existing-worktree --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Continue work on feature X" --cwd /path/to/existing-worktree --agent <current_agent> --user "Tommy"
       \`\`\`
 
       The path must be a git worktree of the project (validated via \`git worktree list\`). The session resolves to the correct project channel but uses the worktree as its working directory. Use \`--worktree\` to create a new worktree, \`--cwd\` to reuse an existing one.
@@ -242,7 +243,7 @@ describe('system-message', () => {
       When you are approaching the **context window limit** or the user explicitly asks to **handoff to a new thread**, use the \`kimaki send\` command to start a fresh session with context:
 
       \`\`\`bash
-      kimaki send --channel chan_123 --prompt "Continuing from previous session: <summary of current task and state>" --user "Tommy"
+      kimaki send --channel chan_123 --prompt "Continuing from previous session: <summary of current task and state>" --agent <current_agent> --user "Tommy"
       \`\`\`
 
       The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
@@ -300,10 +301,10 @@ describe('system-message', () => {
 
       \`\`\`bash
       # Send to a specific channel
-      kimaki send --channel <channel_id> --prompt "Plan how to update the API client to v2"
+      kimaki send --channel <channel_id> --prompt "Plan how to update the API client to v2" --agent <current_agent>
 
       # Or use --project to resolve from directory
-      kimaki send --project /path/to/other-repo --prompt "Plan how to bump version to 1.2.0"
+      kimaki send --project /path/to/other-repo --prompt "Plan how to bump version to 1.2.0" --agent <current_agent>
       \`\`\`
 
       When sending prompts to other projects, always ask the agent to plan first, never build upfront. The prompt should start with "Plan how to ..." so the user can review before greenlighting implementation.
@@ -326,10 +327,10 @@ describe('system-message', () => {
 
       \`\`\`bash
       # Start a session and wait for it to finish
-      kimaki send --channel <channel_id> --prompt "Fix the auth bug" --wait
+      kimaki send --channel <channel_id> --prompt "Fix the auth bug" --wait --agent <current_agent>
 
       # Send to an existing thread and wait
-      kimaki send --thread <thread_id> --prompt "Run the tests" --wait
+      kimaki send --thread <thread_id> --prompt "Run the tests" --wait --agent <current_agent>
       \`\`\`
 
       The command exits with the session markdown on stdout once the model finishes responding.

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

@@ -70,7 +70,6 @@ function writeSystemPromptDiffFile({ dataDir, sessionId, beforePrompt, afterProm
     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, `${timestamp}.md`);
     const fileContent = [
         `Session: ${sessionId}`,
         `Created: ${new Date().toISOString()}`,
@@ -88,7 +87,6 @@ function writeSystemPromptDiffFile({ dataDir, sessionId, beforePrompt, afterProm
                 additions: diff.additions,
                 deletions: diff.deletions,
                 filePath,
-                latestPromptPath,
             };
         },
         catch: (error) => {
@@ -109,6 +107,7 @@ function getOrCreateSessionState({ sessions, sessionId, }) {
         comparedTurn: 0,
         previousTurnContext: undefined,
         currentTurnContext: undefined,
+        pendingCompareTimeout: undefined,
     };
     sessions.set(sessionId, state);
     return state;
@@ -162,8 +161,7 @@ async function handleSystemTransform({ input, output, sessions, dataDir, client,
             message: appendToastSessionMarker({
                 sessionId,
                 message: `system prompt changed since the previous message (+${diffFileResult.additions} / -${diffFileResult.deletions}). ` +
-                    `Diff: \`${abbreviatePath(diffFileResult.filePath)}\`. ` +
-                    `Latest prompt: \`${abbreviatePath(diffFileResult.latestPromptPath)}\``,
+                    `Diff: \`${abbreviatePath(diffFileResult.filePath)}\`. `
             }),
         },
     });
@@ -193,13 +191,41 @@ const systemPromptDriftPlugin = async ({ client, directory }) => {
         'experimental.chat.system.transform': async (input, output) => {
             const result = await errore.tryAsync({
                 try: async () => {
-                    await handleSystemTransform({
-                        input,
-                        output,
-                        sessions,
-                        dataDir,
-                        client,
-                    });
+                    const sessionId = input.sessionID;
+                    if (!sessionId) {
+                        return;
+                    }
+                    const state = getOrCreateSessionState({ sessions, sessionId });
+                    if (state.pendingCompareTimeout) {
+                        clearTimeout(state.pendingCompareTimeout);
+                    }
+                    // Delay one tick so other system-transform hooks can finish mutating
+                    // output.system before we snapshot it for drift detection.
+                    state.pendingCompareTimeout = setTimeout(() => {
+                        state.pendingCompareTimeout = undefined;
+                        void errore.tryAsync({
+                            try: async () => {
+                                await handleSystemTransform({
+                                    input,
+                                    output,
+                                    sessions,
+                                    dataDir,
+                                    client,
+                                });
+                            },
+                            catch: (error) => {
+                                return new Error('system prompt drift transform hook failed', {
+                                    cause: error,
+                                });
+                            },
+                        }).then((delayedResult) => {
+                            if (!(delayedResult instanceof Error)) {
+                                return;
+                            }
+                            logger.warn(`[system-prompt-drift-plugin] ${formatPluginErrorWithStack(delayedResult)}`);
+                            void notifyError(delayedResult, 'system prompt drift plugin transform hook failed');
+                        });
+                    }, 0);
                 },
                 catch: (error) => {
                     return new Error('system prompt drift transform hook failed', {
@@ -222,6 +248,10 @@ const systemPromptDriftPlugin = async ({ client, directory }) => {
                     if (!deletedSessionId) {
                         return;
                     }
+                    const state = sessions.get(deletedSessionId);
+                    if (state?.pendingCompareTimeout) {
+                        clearTimeout(state.pendingCompareTimeout);
+                    }
                     sessions.delete(deletedSessionId);
                 },
                 catch: (error) => {

package/dist/utils.js

@@ -50,7 +50,7 @@ export function generateBotInstallUrl({ clientId, permissions = [
     return url.toString();
 }
 export const KIMAKI_GATEWAY_APP_ID = process.env.KIMAKI_GATEWAY_APP_ID || '1477605701202481173';
-export const KIMAKI_WEBSITE_URL = process.env.KIMAKI_WEBSITE_URL || 'https://kimaki.xyz';
+export const KIMAKI_WEBSITE_URL = process.env.KIMAKI_WEBSITE_URL || 'https://kimaki.dev';
 export function generateDiscordInstallUrlForBot({ appId, mode, clientId, clientSecret, gatewayCallbackUrl, reachableUrl, }) {
     if (mode !== 'gateway') {
         return generateBotInstallUrl({ clientId: appId });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@otto-assistant/bridge",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.97",
+  "version": "0.4.100",
   "scripts": {
     "dev": "tsx src/bin.ts",
     "prepublishOnly": "pnpm generate && pnpm tsc",

package/src/agent-model.e2e.test.ts

@@ -542,7 +542,14 @@ describe('agent model resolution', () => {
         afterAuthorId: discord.botUserId,
       })
 
-      expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
+      const threadText = (await discord.thread(thread.id).text())
+        .split('\n')
+        .filter((line) => {
+          return !line.startsWith('⬦ info: Context cache discarded:')
+        })
+        .join('\n')
+
+      expect(threadText).toMatchInlineSnapshot(`
         "--- from: user (agent-model-tester)
         first message in thread
         Reply with exactly: reply-context-check

package/src/anthropic-auth-plugin.ts

@@ -559,6 +559,8 @@ function toClaudeCodeToolName(name: string) {
 function sanitizeSystemText(text: string, onError?: (msg: string) => void) {
   const startIdx = text.indexOf(OPENCODE_IDENTITY)
   if (startIdx === -1) return text
+  // to find the last heading to match readhttps://github.com/anomalyco/opencode/blob/dev/packages/opencode/src/session/prompt/anthropic.txt
+  // it contains the opencode injected prompt. you must keep the codeRefsMarker updated with that package
   const codeRefsMarker = '# Code References'
   const endIdx = text.indexOf(codeRefsMarker, startIdx)
   if (endIdx === -1) {

package/src/cli-send-thread.e2e.test.ts

@@ -339,14 +339,13 @@ describe('kimaki send --channel thread creation', () => {
         })
 
         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/src/cli.ts

@@ -141,7 +141,7 @@ const cliLogger = createLogger(LogPrefix.CLI)
 // 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,
@@ -3792,7 +3792,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/src/commands/screenshare.test.ts

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

package/src/commands/screenshare.ts

@@ -40,7 +40,7 @@ const activeSessions = new Map<string, ScreenshareSession>()
 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