@otto-assistant/bridge 0.4.96 → 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,12 +213,12 @@ 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.
 
-      By default, worktrees are created from \`origin/HEAD\` (the remote's default branch). To change the base branch for a project, the user can run \`git remote set-head origin <branch>\` in the project directory. For example, \`git remote set-head origin dev\` makes all new worktrees branch off \`origin/dev\` instead of \`origin/main\`.
+      By default, worktrees are created from \`HEAD\`, which means whatever commit or branch the current checkout is on. If you want a different base, pass \`--base-branch\` or use the slash command option explicitly.
 
       Critical recursion guard:
       - If you already are in a worktree thread, do not create another worktree unless the user explicitly asks for a nested worktree.
@@ -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/dist/worktrees.js

@@ -394,39 +394,6 @@ async function validateSubmodulePointers(directory) {
     return new Error(`Submodule validation failed: ${validationIssues.join('; ')}`);
 }
 async function resolveDefaultWorktreeTarget(directory) {
-    const remoteHead = await execAsync('git symbolic-ref refs/remotes/origin/HEAD', {
-        cwd: directory,
-    }).catch(() => {
-        return null;
-    });
-    const remoteRef = remoteHead?.stdout.trim();
-    if (remoteRef?.startsWith('refs/remotes/')) {
-        return remoteRef.replace('refs/remotes/', '');
-    }
-    const hasMain = await execAsync('git show-ref --verify --quiet refs/heads/main', {
-        cwd: directory,
-    })
-        .then(() => {
-        return true;
-    })
-        .catch(() => {
-        return false;
-    });
-    if (hasMain) {
-        return 'main';
-    }
-    const hasMaster = await execAsync('git show-ref --verify --quiet refs/heads/master', {
-        cwd: directory,
-    })
-        .then(() => {
-        return true;
-    })
-        .catch(() => {
-        return false;
-    });
-    if (hasMaster) {
-        return 'master';
-    }
     return 'HEAD';
 }
 function getManagedWorktreeDirectory({ directory, name, }) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@otto-assistant/bridge",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.96",
+  "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-account-identity.test.ts

@@ -0,0 +1,52 @@
+// Tests Anthropic OAuth account identity parsing and normalization.
+
+import { describe, expect, test } from 'vitest'
+import {
+  extractAnthropicAccountIdentity,
+  normalizeAnthropicAccountIdentity,
+} from './anthropic-account-identity.js'
+
+describe('normalizeAnthropicAccountIdentity', () => {
+  test('normalizes email casing and drops empty values', () => {
+    expect(
+      normalizeAnthropicAccountIdentity({
+        email: '  User@Example.com ',
+        accountId: '  user_123  ',
+      }),
+    ).toEqual({
+      email: 'user@example.com',
+      accountId: 'user_123',
+    })
+
+    expect(normalizeAnthropicAccountIdentity({ email: '   ' })).toBeUndefined()
+  })
+})
+
+describe('extractAnthropicAccountIdentity', () => {
+  test('prefers nested user profile identity from client_data responses', () => {
+    expect(
+      extractAnthropicAccountIdentity({
+        organizations: [{ id: 'org_123', name: 'Workspace' }],
+        user: {
+          id: 'usr_123',
+          email: 'User@Example.com',
+        },
+      }),
+    ).toEqual({
+      accountId: 'usr_123',
+      email: 'user@example.com',
+    })
+  })
+
+  test('falls back to profile-style payloads without email', () => {
+    expect(
+      extractAnthropicAccountIdentity({
+        profile: {
+          user_id: 'usr_456',
+        },
+      }),
+    ).toEqual({
+      accountId: 'usr_456',
+    })
+  })
+})

package/src/anthropic-account-identity.ts

@@ -0,0 +1,77 @@
+// Helpers for extracting and normalizing Anthropic OAuth account identity.
+
+export type AnthropicAccountIdentity = {
+  email?: string
+  accountId?: string
+}
+
+type IdentityCandidate = AnthropicAccountIdentity & {
+  score: number
+}
+
+const identityHintKeys = new Set(['user', 'profile', 'account', 'viewer'])
+const idKeys = ['user_id', 'userId', 'account_id', 'accountId', 'id', 'sub']
+
+export function normalizeAnthropicAccountIdentity(
+  identity: AnthropicAccountIdentity | null | undefined,
+) {
+  const email =
+    typeof identity?.email === 'string' && identity.email.trim()
+      ? identity.email.trim().toLowerCase()
+      : undefined
+  const accountId =
+    typeof identity?.accountId === 'string' && identity.accountId.trim()
+      ? identity.accountId.trim()
+      : undefined
+  if (!email && !accountId) return undefined
+  return {
+    ...(email ? { email } : {}),
+    ...(accountId ? { accountId } : {}),
+  }
+}
+
+function getCandidateFromRecord(record: Record<string, unknown>, path: string[]) {
+  const email = typeof record.email === 'string' ? record.email : undefined
+  const accountId = idKeys
+    .map((key) => {
+      const value = record[key]
+      return typeof value === 'string' ? value : undefined
+    })
+    .find((value) => {
+      return Boolean(value)
+    })
+  const normalized = normalizeAnthropicAccountIdentity({ email, accountId })
+  if (!normalized) return undefined
+  const hasIdentityHint = path.some((segment) => {
+    return identityHintKeys.has(segment)
+  })
+  return {
+    ...normalized,
+    score: (normalized.email ? 4 : 0) + (normalized.accountId ? 2 : 0) + (hasIdentityHint ? 2 : 0),
+  } satisfies IdentityCandidate
+}
+
+function collectIdentityCandidates(value: unknown, path: string[] = []): IdentityCandidate[] {
+  if (!value || typeof value !== 'object') return []
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => {
+      return collectIdentityCandidates(entry, path)
+    })
+  }
+
+  const record = value as Record<string, unknown>
+  const nested = Object.entries(record).flatMap(([key, entry]) => {
+    return collectIdentityCandidates(entry, [...path, key])
+  })
+  const current = getCandidateFromRecord(record, path)
+  return current ? [current, ...nested] : nested
+}
+
+export function extractAnthropicAccountIdentity(value: unknown) {
+  const candidates = collectIdentityCandidates(value)
+  const best = candidates.sort((a, b) => {
+    return b.score - a.score
+  })[0]
+  if (!best) return undefined
+  return normalizeAnthropicAccountIdentity(best)
+}

package/src/anthropic-auth-plugin.ts

@@ -35,6 +35,10 @@ import {
   upsertAccount,
   withAuthStateLock,
 } from './anthropic-auth-state.js'
+import {
+  extractAnthropicAccountIdentity,
+  type AnthropicAccountIdentity,
+} from './anthropic-account-identity.js'
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
 // Reference: https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/pkce.ts
 function base64urlEncode(bytes: Uint8Array): string {
@@ -68,6 +72,8 @@ const CLIENT_ID = (() => {
 
 const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token'
 const CREATE_API_KEY_URL = 'https://api.anthropic.com/api/oauth/claude_cli/create_api_key'
+const CLIENT_DATA_URL = 'https://api.anthropic.com/api/oauth/claude_cli/client_data'
+const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile'
 const CALLBACK_PORT = 53692
 const CALLBACK_PATH = '/callback'
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`
@@ -81,6 +87,7 @@ const CLAUDE_CODE_BETA = 'claude-code-20250219'
 const OAUTH_BETA = 'oauth-2025-04-20'
 const FINE_GRAINED_TOOL_STREAMING_BETA = 'fine-grained-tool-streaming-2025-05-14'
 const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14'
+const TOAST_SESSION_HEADER = 'x-kimaki-session-id'
 
 const ANTHROPIC_HOSTS = new Set([
   'api.anthropic.com',
@@ -298,6 +305,28 @@ async function createApiKey(accessToken: string): Promise<ApiKeySuccess> {
   return { type: 'success', key: json.raw_key }
 }
 
+async function fetchAnthropicAccountIdentity(accessToken: string) {
+  const urls = [CLIENT_DATA_URL, PROFILE_URL]
+  for (const url of urls) {
+    const responseText = await requestText(url, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        authorization: `Bearer ${accessToken}`,
+        'user-agent': process.env.OPENCODE_ANTHROPIC_USER_AGENT || `claude-cli/${CLAUDE_CODE_VERSION}`,
+        'x-app': 'cli',
+      },
+    }).catch(() => {
+      return undefined
+    })
+    if (!responseText) continue
+    const parsed = JSON.parse(responseText) as unknown
+    const identity = extractAnthropicAccountIdentity(parsed)
+    if (identity) return identity
+  }
+  return undefined
+}
+
 // --- Localhost callback server ---
 
 type CallbackResult = { code: string; state: string }
@@ -469,12 +498,13 @@ function buildAuthorizeHandler(mode: 'oauth' | 'apikey') {
       if (mode === 'apikey') {
         return createApiKey(creds.access)
       }
+      const identity = await fetchAnthropicAccountIdentity(creds.access)
       await rememberAnthropicOAuth({
         type: 'oauth',
         refresh: creds.refresh,
         access: creds.access,
         expires: creds.expires,
-      })
+      }, identity)
       return creds
     }
 
@@ -489,8 +519,7 @@ function buildAuthorizeHandler(mode: 'oauth' | 'apikey') {
             try {
               const result = await waitForCallback(auth.callbackServer)
               return await finalize(result)
-            } catch (error) {
-              console.error(`[anthropic-auth] ${error}`)
+            } catch {
               return { type: 'failed' }
             }
           })()
@@ -509,8 +538,7 @@ function buildAuthorizeHandler(mode: 'oauth' | 'apikey') {
           try {
             const result = await waitForCallback(auth.callbackServer, input)
             return await finalize(result)
-          } catch (error) {
-            console.error(`[anthropic-auth] ${error}`)
+          } catch {
             return { type: 'failed' }
           }
         })()
@@ -531,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) {
@@ -682,6 +712,19 @@ function wrapResponseStream(response: Response, reverseToolNameMap: Map<string,
   })
 }
 
+function appendToastSessionMarker({
+  message,
+  sessionId,
+}: {
+  message: string
+  sessionId: string | undefined
+}) {
+  if (!sessionId) {
+    return message
+  }
+  return `${message} ${sessionId}`
+}
+
 // --- Beta headers ---
 
 function getRequiredBetas(modelId: string | undefined) {
@@ -737,7 +780,18 @@ async function getFreshOAuth(
     await setAnthropicAuth(refreshed, client)
     const store = await loadAccountStore()
     if (store.accounts.length > 0) {
-      upsertAccount(store, refreshed)
+      const identity: AnthropicAccountIdentity | undefined = (() => {
+        const currentIndex = store.accounts.findIndex((account) => {
+          return account.refresh === latest.refresh || account.access === latest.access
+        })
+        const current = currentIndex >= 0 ? store.accounts[currentIndex] : undefined
+        if (!current) return undefined
+        return {
+          ...(current.email ? { email: current.email } : {}),
+          ...(current.accountId ? { accountId: current.accountId } : {}),
+        }
+      })()
+      upsertAccount(store, { ...refreshed, ...identity })
       await saveAccountStore(store)
     }
     return refreshed
@@ -752,6 +806,12 @@ async function getFreshOAuth(
 
 const AnthropicAuthPlugin: Plugin = async ({ client }) => {
   return {
+    'chat.headers': async (input, output) => {
+      if (input.model.providerID !== 'anthropic') {
+        return
+      }
+      output.headers[TOAST_SESSION_HEADER] = input.sessionID
+    },
     auth: {
       provider: 'anthropic',
       async loader(
@@ -788,21 +848,27 @@ const AnthropicAuthPlugin: Plugin = async ({ client }) => {
                       .catch(() => undefined)
                   : undefined
 
-            const rewritten = rewriteRequestPayload(originalBody, (msg) => {
-              client.tui.showToast({
-                body: { message: msg, variant: 'error' },
-              }).catch(() => {})
-            })
             const headers = new Headers(init?.headers)
             if (input instanceof Request) {
               input.headers.forEach((v, k) => {
                 if (!headers.has(k)) headers.set(k, v)
               })
             }
+            const sessionId = headers.get(TOAST_SESSION_HEADER) ?? undefined
+
+            const rewritten = rewriteRequestPayload(originalBody, (msg) => {
+              client.tui.showToast({
+                body: {
+                  message: appendToastSessionMarker({ message: msg, sessionId }),
+                  variant: 'error',
+                },
+              }).catch(() => {})
+            })
             const betas = getRequiredBetas(rewritten.modelId)
 
             const runRequest = async (auth: OAuthStored) => {
               const requestHeaders = new Headers(headers)
+              requestHeaders.delete(TOAST_SESSION_HEADER)
               requestHeaders.set('accept', 'application/json')
               requestHeaders.set(
                 'anthropic-beta',
@@ -839,9 +905,13 @@ const AnthropicAuthPlugin: Plugin = async ({ client }) => {
                   // Show toast notification so Discord thread shows the rotation
                   client.tui.showToast({
                     body: {
-                      message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
+                      message: appendToastSessionMarker({
+                        message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
+                        sessionId,
+                      }),
                       variant: 'info',
                     },
+
                   }).catch(() => {})
                   const retryAuth = await getFreshOAuth(getAuth, client)
                   if (retryAuth) {