@otto-assistant/bridge 0.4.97 → 0.4.100

package/src/system-message.ts

@@ -363,7 +363,7 @@ export function getOpencodeSystemMessage({
           .join('\n')}`
       : ''
   return `
-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
 
@@ -431,39 +431,40 @@ ${
 
 To start a new thread/session in this channel pro-grammatically, run:
 
-kimaki send --channel ${channelId} --prompt "your prompt here"${userArg}
+kimaki send --channel ${channelId} --prompt "your prompt here" --agent <current_agent>${userArg}
 
 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 ${channelId} --prompt "User cancelled subscription" --notify-only${userArg}
+kimaki send --channel ${channelId} --prompt "User cancelled subscription" --notify-only --agent <current_agent>${userArg}
 
 Use --user to add a specific Discord user to the new thread:
 
-kimaki send --channel ${channelId} --prompt "Review the latest CI failure"${userArg}
+kimaki send --channel ${channelId} --prompt "Review the latest CI failure" --agent <current_agent>${userArg}
 
 Use --worktree to create a git worktree for the session (ONLY when the user explicitly asks for a worktree):
 
-kimaki send --channel ${channelId} --prompt "Add dark mode support" --worktree dark-mode${userArg}
+kimaki send --channel ${channelId} --prompt "Add dark mode support" --worktree dark-mode --agent <current_agent>${userArg}
 
 Use --cwd to start a session in an existing git worktree directory (must be a worktree of the project):
 
-kimaki send --channel ${channelId} --prompt "Continue work on feature" --cwd /path/to/existing-worktree${userArg}
+kimaki send --channel ${channelId} --prompt "Continue work on feature" --cwd /path/to/existing-worktree --agent <current_agent>${userArg}
 
 Important:
 - NEVER use \`--worktree\` unless the user explicitly requests a worktree. Most tasks should use normal threads without worktrees.
@@ -481,8 +482,8 @@ ${availableAgentsContext}
 
 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 ${channelId} --prompt "/build-cmd update dependencies"${userArg}
+kimaki send --thread <thread_id> --prompt "/review fix the auth module" --agent <current_agent>
+kimaki send --channel ${channelId} --prompt "/build-cmd update dependencies" --agent <current_agent>${userArg}
 
 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\`).
 
@@ -492,14 +493,14 @@ The user can switch the active agent mid-session using the Discord slash command
 
 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 ${channelId} --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z"${userArg}
-kimaki send --channel ${channelId} --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1"${userArg}
+kimaki send --channel ${channelId} --prompt "Reminder: review open PRs" --send-at "2026-03-01T09:00:00Z" --agent <current_agent>${userArg}
+kimaki send --channel ${channelId} --prompt "Run weekly test suite and summarize failures" --send-at "0 9 * * 1" --agent <current_agent>${userArg}
 
 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.
@@ -533,13 +534,13 @@ kimaki task delete <id>
 
 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 ${channelId} --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 ${channelId} --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 ${sessionId} --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only
+kimaki send --session ${sessionId} --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.
 
@@ -554,7 +555,7 @@ ONLY create worktrees when the user explicitly asks for one. Never proactively u
 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 ${channelId} --prompt "your task description" --worktree worktree-name${userArg}
+kimaki send --channel ${channelId} --prompt "your task description" --worktree worktree-name --agent <current_agent>${userArg}
 \`\`\`
 
 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.
@@ -570,7 +571,7 @@ Critical recursion guard:
 Use \`--cwd\` to start a session in an existing git worktree directory instead of creating a new one:
 
 \`\`\`bash
-kimaki send --channel ${channelId} --prompt "Continue work on feature X" --cwd /path/to/existing-worktree${userArg}
+kimaki send --channel ${channelId} --prompt "Continue work on feature X" --cwd /path/to/existing-worktree --agent <current_agent>${userArg}
 \`\`\`
 
 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.
@@ -584,7 +585,7 @@ This is useful for automation (cron jobs, GitHub webhooks, n8n, etc.)
 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 ${channelId} --prompt "Continuing from previous session: <summary of current task and state>"${userArg}
+kimaki send --channel ${channelId} --prompt "Continuing from previous session: <summary of current task and state>" --agent <current_agent>${userArg}
 \`\`\`
 
 The command automatically handles long prompts (over 2000 chars) by sending them as file attachments.
@@ -642,10 +643,10 @@ To send a task to another project:
 
 \`\`\`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.
@@ -668,10 +669,10 @@ If your Bash tool timeout triggers anyway, fall back to reading the session outp
 
 \`\`\`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/src/system-prompt-drift-plugin.ts

@@ -33,6 +33,7 @@ type SessionState = {
   comparedTurn: number
   previousTurnContext: TurnContext | undefined
   currentTurnContext: TurnContext | undefined
+  pendingCompareTimeout: ReturnType<typeof setTimeout> | undefined
 }
 
 type SystemPromptDiff = {
@@ -146,7 +147,6 @@ function writeSystemPromptDiffFile({
   additions: number
   deletions: number
   filePath: string
-  latestPromptPath: string
 } {
   const diff = buildPatch({
     beforeText: beforePrompt,
@@ -157,7 +157,7 @@ function writeSystemPromptDiffFile({
   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()}`,
@@ -176,7 +176,6 @@ function writeSystemPromptDiffFile({
           additions: diff.additions,
           deletions: diff.deletions,
           filePath,
-          latestPromptPath,
         }
     },
     catch: (error) => {
@@ -204,6 +203,7 @@ function getOrCreateSessionState({
     comparedTurn: 0,
     previousTurnContext: undefined,
     currentTurnContext: undefined,
+    pendingCompareTimeout: undefined,
   }
   sessions.set(sessionId, state)
   return state
@@ -278,8 +278,7 @@ async function handleSystemTransform({
         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)}\`. `
       }),
     },
   })
@@ -315,13 +314,46 @@ const systemPromptDriftPlugin: Plugin = 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', {
@@ -346,6 +378,10 @@ const systemPromptDriftPlugin: Plugin = async ({ client, directory }) => {
           if (!deletedSessionId) {
             return
           }
+          const state = sessions.get(deletedSessionId)
+          if (state?.pendingCompareTimeout) {
+            clearTimeout(state.pendingCompareTimeout)
+          }
           sessions.delete(deletedSessionId)
         },
         catch: (error) => {

package/src/utils.ts

@@ -82,7 +82,7 @@ export function generateBotInstallUrl({
 
 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,