@otto-assistant/bridge 0.4.93 → 0.4.97

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

@@ -40,6 +40,14 @@ import { extractLeadingOpencodeCommand } from '../opencode-command-detection.js'
 const logger = createLogger(LogPrefix.SESSION);
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const DETERMINISTIC_CONTEXT_LIMIT = 100_000;
+const TOAST_SESSION_ID_REGEX = /\b(ses_[A-Za-z0-9]+)\b\s*$/u;
+function extractToastSessionId({ message }) {
+    const match = message.match(TOAST_SESSION_ID_REGEX);
+    return match?.[1];
+}
+function stripToastSessionId({ message }) {
+    return message.replace(TOAST_SESSION_ID_REGEX, '').trimEnd();
+}
 const shouldLogSessionEvents = process.env['KIMAKI_LOG_SESSION_EVENTS'] === '1' ||
     process.env['KIMAKI_VITEST'] === '1';
 // ── Registry ─────────────────────────────────────────────────────
@@ -943,6 +951,9 @@ export class ThreadSessionRuntime {
         }
         const sessionId = this.state?.sessionId;
         const eventSessionId = getOpencodeEventSessionId(event);
+        const toastSessionId = event.type === 'tui.toast.show'
+            ? extractToastSessionId({ message: event.properties.message })
+            : undefined;
         if (shouldLogSessionEvents) {
             const eventDetails = (() => {
                 if (event.type === 'session.error') {
@@ -970,6 +981,7 @@ export class ThreadSessionRuntime {
             logger.log(`[EVENT] type=${event.type} eventSessionId=${eventSessionId || 'none'} activeSessionId=${sessionId || 'none'} ${this.formatRunStateForLog()}${eventDetails}`);
         }
         const isGlobalEvent = event.type === 'tui.toast.show';
+        const isScopedToastEvent = Boolean(toastSessionId);
         // Drop events that don't match current session (stale events from
         // previous sessions), unless it's a global event or a subtask session.
         if (!isGlobalEvent && eventSessionId && eventSessionId !== sessionId) {
@@ -977,6 +989,11 @@ export class ThreadSessionRuntime {
                 return; // stale event from previous session
             }
         }
+        if (isScopedToastEvent && toastSessionId !== sessionId) {
+            if (!this.getSubtaskInfoForSession(toastSessionId)) {
+                return;
+            }
+        }
         if (isOpencodeSessionEventLogEnabled()) {
             const eventLogResult = await appendOpencodeSessionEventLog({
                 threadId: this.threadId,
@@ -2023,7 +2040,7 @@ export class ThreadSessionRuntime {
         if (properties.variant === 'warning') {
             return;
         }
-        const toastMessage = properties.message.trim();
+        const toastMessage = stripToastSessionId({ message: properties.message }).trim();
         if (!toastMessage) {
             return;
         }

package/dist/system-message.js

@@ -450,7 +450,7 @@ kimaki send --channel ${channelId} --prompt "your task description" --worktree w
 
 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.

package/dist/system-message.test.js

@@ -217,7 +217,7 @@ describe('system-message', () => {
 
       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.

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

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

package/dist/utils.js

@@ -2,7 +2,11 @@
 // Includes Discord OAuth URL generation, array deduplication,
 // abort error detection, and date/time formatting helpers.
 import os from 'node:os';
-import { PermissionsBitField } from 'discord.js';
+// Use namespace import for CJS interop — discord.js is CJS and its named
+// exports aren't detectable by all ESM loaders (e.g. tsx/esbuild) because
+// discord.js uses tslib's __exportStar which is opaque to static analysis.
+import * as discord from 'discord.js';
+const { PermissionsBitField } = discord;
 import * as errore from 'errore';
 export function generateBotInstallUrl({ clientId, permissions = [
     PermissionsBitField.Flags.ViewChannel,

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.93",
+  "version": "0.4.97",
   "scripts": {
     "dev": "tsx src/bin.ts",
     "prepublishOnly": "pnpm generate && pnpm tsc",
@@ -66,6 +66,7 @@
     "@prisma/client": "7.4.2",
     "@purinton/resampler": "^1.0.4",
     "cron-parser": "^5.5.0",
+    "diff": "^8.0.4",
     "discord.js": "^14.25.1",
     "domhandler": "^6.0.1",
     "errore": "workspace:^",

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)
+}