vellum 0.2.1 → 0.2.7

package/src/daemon/session-attachments.ts

@@ -3,7 +3,8 @@ import type { UserMessageAttachment } from './ipc-protocol.js';
 import { check, classifyRisk, generateAllowlistOptions, generateScopeOptions } from '../permissions/checker.js';
 import { addRule } from '../permissions/trust-store.js';
 import type { PermissionPrompter } from '../permissions/prompter.js';
-import { uploadAttachment, linkAttachmentToMessage, AttachmentUploadError } from '../memory/attachments-store.js';
+import { uploadAttachment, linkAttachmentToMessage, setAttachmentThumbnail, AttachmentUploadError } from '../memory/attachments-store.js';
+import { generateVideoThumbnail } from './video-thumbnail.js';
 import {
   resolveDirectives,
   contentBlocksToDrafts,
@@ -92,7 +93,6 @@ export async function resolveAssistantAttachments(
   workingDir: string,
   approveHostRead: ApproveHostRead,
   lastAssistantMessageId: string | undefined,
-  assistantScope: string,
 ): Promise<AttachmentResolutionResult> {
   let assistantAttachments: AssistantAttachmentDraft[] = [];
   const emittedAttachments: UserMessageAttachment[] = [];
@@ -131,14 +131,17 @@ export async function resolveAssistantAttachments(
     log.info('No directives or tool content blocks to resolve');
   }
 
-  // Persist resolved attachments and link to the last assistant message
+  // Persist resolved attachments and link to the last assistant message.
+  // Large video attachments are omitted from the IPC payload and lazy-loaded
+  // by the client via the HTTP endpoint (same pattern as history_response).
+  const MAX_INLINE_B64_SIZE = 512 * 1024;
+
   if (assistantAttachments.length > 0 && lastAssistantMessageId) {
     for (let i = 0; i < assistantAttachments.length; i++) {
       const draft = assistantAttachments[i];
       let stored;
       try {
         stored = uploadAttachment(
-          assistantScope,
           draft.filename,
           draft.mimeType,
           draft.dataBase64,
@@ -152,11 +155,31 @@ export async function resolveAssistantAttachments(
         throw err;
       }
       linkAttachmentToMessage(lastAssistantMessageId, stored.id, i);
+      const isVideo = draft.mimeType.startsWith('video/');
+      const omitData = isVideo && draft.dataBase64.length > MAX_INLINE_B64_SIZE;
+
+      // Generate and persist a thumbnail for video attachments.
+      let thumbnailData: string | undefined;
+      if (isVideo) {
+        const existing = stored.thumbnailBase64;
+        if (existing) {
+          thumbnailData = existing;
+        } else {
+          const generated = await generateVideoThumbnail(draft.dataBase64);
+          if (generated) {
+            setAttachmentThumbnail(stored.id, generated);
+            thumbnailData = generated;
+          }
+        }
+      }
+
       emittedAttachments.push({
         id: stored.id,
         filename: draft.filename,
         mimeType: draft.mimeType,
-        data: draft.dataBase64,
+        data: omitData ? '' : draft.dataBase64,
+        ...(omitData ? { sizeBytes: draft.sizeBytes } : {}),
+        ...(thumbnailData ? { thumbnailData } : {}),
       });
     }
   } else if (assistantAttachments.length > 0) {

package/src/daemon/session-conflict-gate.ts

@@ -1,8 +1,8 @@
 /**
  * Conflict-gate logic extracted from Session.
  *
- * Decides whether to ask the user about a pending memory conflict (relevant gate),
- * inject a soft instruction (irrelevant gate), or skip entirely.
+ * Decides whether to ask the user about a pending memory conflict (relevant gate)
+ * or skip entirely.
  */
 
 import {
@@ -12,6 +12,11 @@ import {
 } from '../memory/conflict-store.js';
 import type { PendingConflictDetail } from '../memory/conflict-store.js';
 import { resolveConflictClarification } from '../memory/clarification-resolver.js';
+import {
+  computeConflictRelevance,
+  looksLikeClarificationReply,
+  shouldAttemptConflictResolution,
+} from '../memory/conflict-intent.js';
 
 export interface ConflictGateDecision {
   question: string;
@@ -39,14 +44,14 @@ export class ConflictGate {
     const threshold = conflictConfig.relevanceThreshold;
     const cooldownTurns = Math.max(1, conflictConfig.reaskCooldownTurns);
     const pendingBeforeResolve = listPendingConflictDetails(scopeId, 50);
+    const clarificationReply = looksLikeClarificationReply(userMessage);
     const candidatesBeforeResolve = pendingBeforeResolve.filter((conflict) => {
       const relevance = computeConflictRelevance(userMessage, conflict);
-      if (relevance >= threshold) return true;
-      // Only try to resolve recently-asked conflicts when the user message
-      // looks like a short clarification reply (e.g. "keep the new one"),
-      // not a full unrelated question that happens to contain cue words.
-      return this.wasRecentlyAsked(conflict.id, cooldownTurns)
-        && looksLikeClarificationReply(userMessage);
+      return shouldAttemptConflictResolution({
+        clarificationReply,
+        relevance,
+        wasRecentlyAsked: this.wasRecentlyAsked(conflict.id, cooldownTurns),
+      });
     });
     await this.resolvePendingConflicts(
       userMessage,
@@ -61,18 +66,16 @@ export class ConflictGate {
       conflict,
       relevance: computeConflictRelevance(userMessage, conflict),
     }));
-    const relevant = scored.filter((entry) => entry.relevance >= threshold);
-    const irrelevant = scored.filter((entry) => entry.relevance < threshold);
-    const ordered = [...relevant, ...irrelevant];
-
-    const askable = ordered.find((entry) => this.shouldAsk(entry.conflict.id, cooldownTurns));
+    const askable = scored
+      .filter((entry) => entry.relevance >= threshold)
+      .find((entry) => this.shouldAsk(entry.conflict.id, cooldownTurns));
     if (!askable) return null;
 
     this.lastAskedTurn.set(askable.conflict.id, this.turnCounter);
     markConflictAsked(askable.conflict.id);
     return {
       question: askable.conflict.clarificationQuestion ?? buildFallbackConflictQuestion(askable.conflict),
-      relevant: askable.relevance >= threshold,
+      relevant: true,
     };
   }
 
@@ -122,98 +125,4 @@ export function buildFallbackConflictQuestion(conflict: PendingConflictDetail):
     'Which one should I keep?',
   ].join('\n');
 }
-
-export function computeConflictRelevance(
-  userMessage: string,
-  conflict: Pick<PendingConflictDetail, 'existingStatement' | 'candidateStatement'>,
-): number {
-  const queryTokens = tokenizeForConflictRelevance(userMessage);
-  if (queryTokens.size === 0) return 0;
-  const existingTokens = tokenizeForConflictRelevance(conflict.existingStatement);
-  const candidateTokens = tokenizeForConflictRelevance(conflict.candidateStatement);
-  return Math.max(
-    overlapRatio(queryTokens, existingTokens),
-    overlapRatio(queryTokens, candidateTokens),
-  );
-}
-
-function tokenizeForConflictRelevance(input: string): Set<string> {
-  const tokens = input
-    .toLowerCase()
-    .split(/[^a-z0-9]+/g)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 4);
-  return new Set(tokens);
-}
-
-function overlapRatio(left: Set<string>, right: Set<string>): number {
-  if (left.size === 0 || right.size === 0) return 0;
-  let overlap = 0;
-  for (const token of left) {
-    if (right.has(token)) overlap += 1;
-  }
-  return overlap / Math.max(left.size, right.size);
-}
-
-// Action verbs that signal the user is making a deliberate choice.
-const ACTION_CUES = new Set([
-  'keep', 'use', 'prefer', 'go', 'pick', 'choose', 'take', 'want', 'select',
-]);
-
-// Directional/merge cue words mirrored from clarification-resolver.ts heuristics.
-const DIRECTIONAL_CUES = new Set([
-  'existing', 'old', 'previous', 'first', 'earlier', 'original',
-  'candidate', 'new', 'latest', 'second', 'updated', 'instead', 'replace',
-  'both', 'merge', 'combine', 'together', 'either', 'mix',
-  'option', 'former', 'latter',
-]);
-
-const MAX_REPLY_WORD_COUNT = 12;
-
-// Direction-only matches (no action verb) must be very short to avoid
-// false positives from unrelated statements that happen to contain
-// common words like "new", "old", "option", etc.
-const MAX_DIRECTION_ONLY_WORD_COUNT = 4;
-
-// Messages starting with a question word are unlikely to be clarification
-// replies even when they lack a trailing question mark.
-const QUESTION_WORD_PREFIXES = new Set([
-  'what', 'how', 'why', 'where', 'when', 'which', 'who', 'whom', 'whose',
-]);
-
-/**
- * Determines whether a user message looks like a deliberate reply to a
- * recently asked conflict clarification (e.g. "keep the new one", "both",
- * "option B", "new one"). Requires at least one action or directional cue,
- * and the message must be short. Questions and longer statements are excluded
- * to prevent accidental resolution from unrelated messages.
- *
- * When only directional cues are present (no action verb), the message must
- * be very short (<= 4 words) to avoid false positives from unrelated messages
- * like "What's new in Bun" or "try the old approach".
- */
-export function looksLikeClarificationReply(userMessage: string): boolean {
-  const trimmed = userMessage.trim();
-  if (trimmed.endsWith('?')) return false;
-
-  const words = trimmed.toLowerCase().split(/\s+/).filter(Boolean);
-  if (words.length === 0 || words.length > MAX_REPLY_WORD_COUNT) return false;
-
-  const normalized = words.map((w) => w.replace(/[^a-z]/g, ''));
-
-  // Reject messages that start with a question word (even without '?').
-  // Match exact question words or contractions (e.g. "what's", "where's"),
-  // but not words that merely share a prefix (e.g. "whichever", "however").
-  const firstWord = words[0];
-  const firstNorm = normalized[0];
-  for (const qw of QUESTION_WORD_PREFIXES) {
-    if (firstNorm === qw || (firstWord.startsWith(qw) && "'\u2018\u2019".includes(firstWord[qw.length]))) return false;
-  }
-
-  const hasAction = normalized.some((w) => ACTION_CUES.has(w));
-  const hasDirection = normalized.some((w) => DIRECTIONAL_CUES.has(w));
-
-  if (hasAction) return true;
-  if (hasDirection) return words.length <= MAX_DIRECTION_ONLY_WORD_COUNT;
-  return false;
-}
+export { computeConflictRelevance, looksLikeClarificationReply };

package/src/daemon/session-error.ts

@@ -41,7 +41,16 @@ const CONTEXT_TOO_LARGE_PATTERNS = [
   /prompt.?is.?too.?long/i,
   /request too large/i,
   /too many.*input.*tokens/i,
-  /max_tokens/i,
+  /max_tokens.*exceeded/i,
+  /exceeded.*max_tokens/i,
+];
+
+// Generic timeout patterns — checked after NETWORK_PATTERNS and PROVIDER_API_PATTERNS
+// so that "connection timeout" → PROVIDER_NETWORK and "gateway timeout" → PROVIDER_API
+const TIMEOUT_PATTERNS = [
+  /\btimeout\b/i,
+  /deadline.?exceeded/i,
+  /request.?timed?.?out/i,
 ];
 
 // Provider API error patterns (5xx, server error, etc.)
@@ -210,7 +219,7 @@ function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debug
     }
   }
 
-  // Network errors
+  // Network errors (before timeout so "connection timeout" is classified as network)
   for (const pattern of NETWORK_PATTERNS) {
     if (pattern.test(message)) {
       return {
@@ -221,7 +230,7 @@ function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debug
     }
   }
 
-  // Provider API errors (5xx)
+  // Provider API errors (before timeout so "gateway timeout" keeps its specific message)
   for (const pattern of PROVIDER_API_PATTERNS) {
     if (pattern.test(message)) {
       return {
@@ -232,6 +241,18 @@ function classifyByMessage(message: string): Omit<ClassifiedSessionError, 'debug
     }
   }
 
+  // Generic timeout errors (checked after network and provider API patterns so
+  // specific timeouts like "connection timeout" and "gateway timeout" aren't misclassified)
+  for (const pattern of TIMEOUT_PATTERNS) {
+    if (pattern.test(message)) {
+      return {
+        code: 'PROVIDER_API',
+        userMessage: 'The request took too long. This is usually temporary — try again shortly.',
+        retryable: true,
+      };
+    }
+  }
+
   // Non-user abort/failure (e.g. AbortError from internal logic, not user cancel)
   for (const pattern of CANCEL_PATTERNS) {
     if (pattern.test(message)) {

package/src/daemon/session-lifecycle.ts

@@ -0,0 +1,147 @@
+/**
+ * Session lifecycle methods extracted from Session: loadFromDb, abort,
+ * and dispose. Each operates on a context interface so the Session class
+ * can delegate without exposing its full surface.
+ */
+
+import type { Message, ContentBlock } from '../providers/types.js';
+import type { UsageStats, SurfaceType, SurfaceData } from './ipc-protocol.js';
+import { repairHistory } from './history-repair.js';
+import { createContextSummaryMessage } from '../context/window-manager.js';
+import * as conversationStore from '../memory/conversation-store.js';
+import type { PermissionPrompter } from '../permissions/prompter.js';
+import type { SecretPrompter } from '../permissions/secret-prompter.js';
+import type { ToolProfiler } from '../events/tool-profiling-listener.js';
+import type { EventBus } from '../events/bus.js';
+import type { AssistantDomainEvents } from '../events/domain-events.js';
+import type { MessageQueue } from './session-queue-manager.js';
+import { getHookManager } from '../hooks/manager.js';
+import { getLogger } from '../util/logger.js';
+import { unregisterWatchNotifiers, unregisterCallNotifiers } from './session-notifiers.js';
+import { unregisterSessionSender } from '../tools/browser/browser-screencast.js';
+import { resetSkillToolProjection } from './session-skill-tools.js';
+
+const log = getLogger('session-lifecycle');
+
+// ── Context Interfaces ───────────────────────────────────────────────
+
+export interface LoadFromDbContext {
+  readonly conversationId: string;
+  messages: Message[];
+  usageStats: UsageStats;
+  contextCompactedMessageCount: number;
+  contextCompactedAt: number | null;
+}
+
+export interface AbortContext {
+  readonly conversationId: string;
+  processing: boolean;
+  abortController: AbortController | null;
+  prompter: PermissionPrompter;
+  secretPrompter: SecretPrompter;
+  pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
+  surfaceState: Map<string, { surfaceType: SurfaceType; data: SurfaceData }>;
+  readonly queue: MessageQueue;
+}
+
+export interface DisposeContext extends AbortContext {
+  eventBus: EventBus<AssistantDomainEvents>;
+  readonly skillProjectionState: Map<string, string>;
+  profiler: ToolProfiler;
+  messages: Message[];
+  surfaceUndoStacks: Map<string, string[]>;
+  currentTurnSurfaces: Array<unknown>;
+  lastSurfaceAction: Map<string, unknown>;
+  workspaceTopLevelContext: string | null;
+  abort(): void;
+}
+
+// ── loadFromDb ───────────────────────────────────────────────────────
+
+export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
+  const dbMessages = conversationStore.getMessages(ctx.conversationId);
+
+  const conv = conversationStore.getConversation(ctx.conversationId);
+  const contextSummary = conv?.contextSummary?.trim() || null;
+  ctx.contextCompactedMessageCount = Math.max(
+    0,
+    Math.min(conv?.contextCompactedMessageCount ?? 0, dbMessages.length),
+  );
+  ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
+
+  const parsedMessages: Message[] = dbMessages
+    .slice(ctx.contextCompactedMessageCount)
+    .map((m) => {
+      const role = m.role as 'user' | 'assistant';
+      let content: ContentBlock[];
+      try {
+        const parsed = JSON.parse(m.content);
+        content = Array.isArray(parsed) ? parsed : [{ type: 'text', text: m.content }];
+      } catch {
+        log.warn({ conversationId: ctx.conversationId, messageId: m.id }, 'Invalid JSON in persisted message content, replacing with safe text block');
+        content = [{ type: 'text', text: m.content }];
+      }
+      return { role, content };
+    });
+
+  const { messages: repairedMessages, stats } = repairHistory(parsedMessages);
+  if (stats.assistantToolResultsMigrated > 0 || stats.missingToolResultsInserted > 0 || stats.orphanToolResultsDowngraded > 0 || stats.consecutiveSameRoleMerged > 0) {
+    log.warn({ conversationId: ctx.conversationId, phase: 'load', ...stats }, 'Repaired persisted history');
+  }
+  ctx.messages = repairedMessages;
+
+  if (contextSummary) {
+    ctx.messages.unshift(createContextSummaryMessage(contextSummary));
+  }
+
+  if (conv) {
+    ctx.usageStats = {
+      inputTokens: conv.totalInputTokens,
+      outputTokens: conv.totalOutputTokens,
+      estimatedCost: conv.totalEstimatedCost,
+    };
+  }
+
+  log.info({ conversationId: ctx.conversationId, count: ctx.messages.length }, 'Loaded messages from DB');
+}
+
+// ── abort ─────────────────────────────────────────────────────────────
+
+export function abortSession(ctx: AbortContext): void {
+  if (ctx.processing) {
+    log.info({ conversationId: ctx.conversationId }, 'Aborting in-flight processing');
+    ctx.abortController?.abort();
+    ctx.prompter.dispose();
+    ctx.secretPrompter.dispose();
+    ctx.pendingSurfaceActions.clear();
+    ctx.surfaceState.clear();
+    unregisterWatchNotifiers(ctx.conversationId);
+    for (const queued of ctx.queue) {
+      queued.onEvent({ type: 'generation_cancelled', sessionId: ctx.conversationId });
+    }
+    ctx.queue.clear();
+  }
+}
+
+// ── dispose ──────────────────────────────────────────────────────────
+
+export function disposeSession(ctx: DisposeContext): void {
+  void getHookManager().trigger('session-end', {
+    sessionId: ctx.conversationId,
+  });
+  ctx.abort();
+  unregisterCallNotifiers(ctx.conversationId);
+  unregisterSessionSender(ctx.conversationId);
+  resetSkillToolProjection(ctx.skillProjectionState);
+  ctx.eventBus.dispose();
+
+  // Release heavy in-memory data so GC can reclaim it
+  ctx.messages = [];
+  ctx.profiler.clear();
+  ctx.surfaceUndoStacks.clear();
+  ctx.currentTurnSurfaces = [];
+  ctx.pendingSurfaceActions.clear();
+  ctx.surfaceState.clear();
+  ctx.lastSurfaceAction.clear();
+  ctx.workspaceTopLevelContext = null;
+}

package/src/daemon/session-media-retry.ts

@@ -0,0 +1,147 @@
+/**
+ * Media payload trimming for context-too-large retry scenarios.
+ *
+ * When the provider rejects a request because the context is too large,
+ * this module replaces older image and file content blocks with lightweight
+ * text stubs to shrink the payload before retrying.
+ */
+
+import type { Message, ContentBlock } from '../providers/types.js';
+import { getSummaryFromContextMessage } from '../context/window-manager.js';
+
+const RETRY_KEEP_LATEST_MEDIA_BLOCKS = 3;
+const MAX_MEDIA_STUB_TEXT = 2_000;
+
+export function stripMediaPayloadsForRetry(messages: Message[]): { messages: Message[]; modified: boolean; replacedBlocks: number; latestUserIndex: number | null } {
+  let latestUserIndex: number | null = null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== 'user') continue;
+    if (getSummaryFromContextMessage(msg) !== null) continue;
+    if (isToolResultOnlyMessage(msg)) continue;
+    latestUserIndex = i;
+    break;
+  }
+
+  let modified = false;
+  let replacedBlocks = 0;
+  let keptLatestMediaBlocks = 0;
+
+  const nextMessages = messages.map((msg, msgIndex) => {
+    const nextContent: ContentBlock[] = [];
+    for (const block of msg.content) {
+      if (block.type === 'image') {
+        const keep = latestUserIndex === msgIndex && keptLatestMediaBlocks < RETRY_KEEP_LATEST_MEDIA_BLOCKS;
+        if (keep) {
+          keptLatestMediaBlocks += 1;
+          nextContent.push(block);
+        } else {
+          replacedBlocks += 1;
+          modified = true;
+          nextContent.push(imageBlockToStub(block));
+        }
+        continue;
+      }
+
+      if (block.type === 'file') {
+        const keep = latestUserIndex === msgIndex && keptLatestMediaBlocks < RETRY_KEEP_LATEST_MEDIA_BLOCKS;
+        if (keep) {
+          keptLatestMediaBlocks += 1;
+          nextContent.push(block);
+        } else {
+          replacedBlocks += 1;
+          modified = true;
+          nextContent.push(fileBlockToStub(block));
+        }
+        continue;
+      }
+
+      if (block.type === 'tool_result' && block.contentBlocks && block.contentBlocks.length > 0) {
+        let toolResultChanged = false;
+        const nextToolContentBlocks: ContentBlock[] = block.contentBlocks.map((cb) => {
+          if (cb.type === 'image') {
+            replacedBlocks += 1;
+            modified = true;
+            toolResultChanged = true;
+            return imageBlockToStub(cb);
+          }
+          if (cb.type === 'file') {
+            replacedBlocks += 1;
+            modified = true;
+            toolResultChanged = true;
+            return fileBlockToStub(cb);
+          }
+          return cb;
+        });
+        if (toolResultChanged) {
+          nextContent.push({ ...block, contentBlocks: nextToolContentBlocks });
+        } else {
+          nextContent.push(block);
+        }
+        continue;
+      }
+
+      nextContent.push(block);
+    }
+    return { ...msg, content: nextContent };
+  });
+
+  return {
+    messages: modified ? nextMessages : messages,
+    modified,
+    replacedBlocks,
+    latestUserIndex,
+  };
+}
+
+function imageBlockToStub(block: Extract<ContentBlock, { type: 'image' }>): Extract<ContentBlock, { type: 'text' }> {
+  const sizeBytes = Math.ceil(block.source.data.length / 4) * 3;
+  return {
+    type: 'text',
+    text: `[Image omitted from retry context: ${block.source.media_type}, ${sizeBytes} bytes]`,
+  };
+}
+
+function fileBlockToStub(block: Extract<ContentBlock, { type: 'file' }>): Extract<ContentBlock, { type: 'text' }> {
+  const sizeBytes = Math.ceil(block.source.data.length / 4) * 3;
+  const extracted = (block.extracted_text ?? '').trim();
+  const preview = extracted.length > MAX_MEDIA_STUB_TEXT
+    ? `${extracted.slice(0, MAX_MEDIA_STUB_TEXT)}...`
+    : extracted;
+  return {
+    type: 'text',
+    text: preview.length > 0
+      ? `[File omitted from retry context: ${block.source.filename} (${block.source.media_type}, ${sizeBytes} bytes)]\n${preview}`
+      : `[File omitted from retry context: ${block.source.filename} (${block.source.media_type}, ${sizeBytes} bytes)]`,
+  };
+}
+
+function isToolResultOnlyMessage(message: Message): boolean {
+  return message.content.length > 0
+    && message.content.every((block) => block.type === 'tool_result');
+}
+
+/**
+ * Race a promise against a timeout. Returns 'completed' if the promise
+ * resolves/rejects within the budget, or 'timed_out' if the timeout fires
+ * first. The timer is always cleared in `finally` to prevent handle leaks.
+ */
+export async function raceWithTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+): Promise<'completed' | 'timed_out'> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const result = await Promise.race([
+      promise.then(() => 'completed' as const, () => 'completed' as const),
+      new Promise<'timed_out'>((resolve) => {
+        timer = setTimeout(() => resolve('timed_out'), timeoutMs);
+      }),
+    ]);
+    return result;
+  } finally {
+    if (timer !== undefined) {
+      clearTimeout(timer);
+    }
+  }
+}