@vellumai/assistant 0.4.29 → 0.4.31

package/src/daemon/session-agent-loop.ts

@@ -453,50 +453,7 @@ export async function runAgentLoopImpl(
       onEvent,
     );
 
-    if (memoryResult.conflictClarification) {
-      const loopChannelMeta = {
-        ...provenanceFromTrustContext(ctx.trustContext),
-        userMessageChannel: capturedTurnChannelContext.userMessageChannel,
-        assistantMessageChannel:
-          capturedTurnChannelContext.assistantMessageChannel,
-        userMessageInterface: capturedTurnInterfaceContext.userMessageInterface,
-        assistantMessageInterface:
-          capturedTurnInterfaceContext.assistantMessageInterface,
-      };
-      const assistantMessage = createAssistantMessage(
-        memoryResult.conflictClarification,
-      );
-      await conversationStore.addMessage(
-        ctx.conversationId,
-        "assistant",
-        JSON.stringify(assistantMessage.content),
-        loopChannelMeta,
-      );
-      ctx.messages.push(assistantMessage);
-      onEvent({
-        type: "assistant_text_delta",
-        text: memoryResult.conflictClarification,
-        sessionId: ctx.conversationId,
-      });
-      ctx.traceEmitter.emit(
-        "message_complete",
-        "Conflict clarification requested (relevant)",
-        {
-          requestId: reqId,
-          status: "info",
-          attributes: { conflictGate: "relevant" },
-        },
-      );
-      onEvent({ type: "message_complete", sessionId: ctx.conversationId });
-      return;
-    }
-
-    const {
-      recall,
-      dynamicProfile,
-      softConflictInstruction,
-      recallInjectionStrategy,
-    } = memoryResult;
+    const { recall, dynamicProfile, recallInjectionStrategy } = memoryResult;
     runMessages = memoryResult.runMessages;
 
     // Build active surface context
@@ -585,7 +542,6 @@ export async function runAgentLoopImpl(
 
     // Shared injection options — reused whenever we need to re-inject after reduction.
     const injectionOpts = {
-      softConflictInstruction,
       activeSurface,
       workspaceTopLevelContext: ctx.workspaceTopLevelContext,
       channelCapabilities: ctx.channelCapabilities ?? null,
@@ -1238,6 +1194,7 @@ export async function runAgentLoopImpl(
           ctx.hasNoClient,
         ),
       state.lastAssistantMessageId,
+      state.toolContentBlockToolNames,
     );
     const { assistantAttachments, emittedAttachments } = attachmentResult;
 

package/src/daemon/session-attachments.ts

@@ -124,6 +124,7 @@ export async function resolveAssistantAttachments(
   workingDir: string,
   approveHostRead: ApproveHostRead,
   lastAssistantMessageId: string | undefined,
+  toolContentBlockToolNames?: ReadonlyMap<number, string>,
 ): Promise<AttachmentResolutionResult> {
   let assistantAttachments: AssistantAttachmentDraft[] = [];
   const emittedAttachments: UserMessageAttachment[] = [];
@@ -170,7 +171,10 @@ export async function resolveAssistantAttachments(
       "Directive resolution complete",
     );
 
-    const toolDrafts = contentBlocksToDrafts(accumulatedToolContentBlocks);
+    const toolDrafts = contentBlocksToDrafts(
+      accumulatedToolContentBlocks,
+      toolContentBlockToolNames,
+    );
     // Most recent tool outputs (e.g., final browser screenshot) should win
     // the MAX_ASSISTANT_ATTACHMENTS cap over older intermediate screenshots.
     toolDrafts.reverse();

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

@@ -1,8 +1,10 @@
 /**
  * Conflict-gate logic extracted from Session.
  *
- * Decides whether to ask the user about a pending memory conflict (relevant gate)
- * or skip entirely.
+ * Handles pending memory conflicts internally: dismisses non-user-evidenced
+ * and non-actionable conflicts, and attempts resolution when the user's reply
+ * looks like an explicit clarification with topical relevance. Never produces
+ * user-facing clarification text.
  */
 
 import { resolveConflictClarification } from "../memory/clarification-resolver.js";
@@ -14,47 +16,34 @@ import {
 } from "../memory/conflict-intent.js";
 import {
   isConflictKindPairEligible,
+  isConflictUserEvidenced,
   isStatementConflictEligible,
 } from "../memory/conflict-policy.js";
 import type { PendingConflictDetail } from "../memory/conflict-store.js";
 import {
   applyConflictResolution,
   listPendingConflictDetails,
-  markConflictAsked,
   resolveConflict,
 } from "../memory/conflict-store.js";
 
-export interface ConflictGateDecision {
-  question: string;
-  relevant: boolean;
-}
-
 export class ConflictGate {
-  private turnCounter = 0;
-  private lastAskedTurn = new Map<string, number>();
-
   async evaluate(
     userMessage: string,
     conflictConfig: {
       enabled: boolean;
       gateMode: string;
       relevanceThreshold: number;
-      reaskCooldownTurns: number;
       resolverLlmTimeoutMs: number;
-      askOnIrrelevantTurns: boolean;
       conflictableKinds: readonly string[];
     },
     scopeId = "default",
-  ): Promise<ConflictGateDecision | null> {
-    if (!conflictConfig.enabled || conflictConfig.gateMode !== "soft")
-      return null;
+  ): Promise<void> {
+    if (!conflictConfig.enabled || conflictConfig.gateMode !== "soft") return;
 
-    this.turnCounter += 1;
-    const threshold = conflictConfig.relevanceThreshold;
-    const cooldownTurns = Math.max(1, conflictConfig.reaskCooldownTurns);
     const pendingBeforeResolve = listPendingConflictDetails(scopeId, 50);
 
-    // Dismiss non-actionable conflicts (kind/statement policy or incoherent pair)
+    // Dismiss non-actionable conflicts (kind/statement policy, incoherent pair,
+    // or assistant-inferred-only provenance with no user evidence)
     const dismissedIds = new Set<string>();
     for (const conflict of pendingBeforeResolve) {
       const dismissReason = this.getDismissReason(
@@ -73,13 +62,15 @@ export class ConflictGate {
     const actionablePending = pendingBeforeResolve.filter(
       (c) => !dismissedIds.has(c.id),
     );
+
+    // Attempt resolution only for explicit clarification-like replies with
+    // topical relevance to the conflict statements
     const clarificationReply = looksLikeClarificationReply(userMessage);
     const candidatesBeforeResolve = actionablePending.filter((conflict) => {
       const relevance = computeConflictRelevance(userMessage, conflict);
       return shouldAttemptConflictResolution({
         clarificationReply,
         relevance,
-        wasRecentlyAsked: this.wasRecentlyAsked(conflict.id, cooldownTurns),
       });
     });
     await this.resolvePendingConflicts(
@@ -87,45 +78,6 @@ export class ConflictGate {
       conflictConfig.resolverLlmTimeoutMs,
       candidatesBeforeResolve,
     );
-
-    const pending = listPendingConflictDetails(scopeId, 50);
-    if (pending.length === 0) return null;
-
-    const scored = pending.map((conflict) => ({
-      conflict,
-      relevance: computeConflictRelevance(userMessage, conflict),
-    }));
-    // Try relevant conflicts first
-    const askable = scored
-      .filter((entry) => entry.relevance >= threshold)
-      .find((entry) => this.shouldAsk(entry.conflict.id, cooldownTurns));
-
-    // If no relevant conflict to ask and askOnIrrelevantTurns is enabled, try ones
-    // below the threshold (including zero-relevance). Zero-relevance conflicts are
-    // surfaced but not tracked as asked, preventing wasRecentlyAsked from triggering
-    // heuristic resolution on subsequent unrelated turns.
-    const candidateToAsk =
-      askable ??
-      (conflictConfig.askOnIrrelevantTurns
-        ? scored.find(
-            (entry) =>
-              entry.relevance < threshold &&
-              this.shouldAsk(entry.conflict.id, cooldownTurns),
-          )
-        : undefined);
-
-    if (!candidateToAsk) return null;
-
-    if (askable || candidateToAsk.relevance > 0) {
-      this.lastAskedTurn.set(candidateToAsk.conflict.id, this.turnCounter);
-      markConflictAsked(candidateToAsk.conflict.id);
-    }
-    return {
-      question:
-        candidateToAsk.conflict.clarificationQuestion ??
-        buildFallbackConflictQuestion(candidateToAsk.conflict),
-      relevant: candidateToAsk.relevance >= threshold,
-    };
   }
 
   private async resolvePendingConflicts(
@@ -156,18 +108,6 @@ export class ConflictGate {
     }
   }
 
-  private shouldAsk(conflictId: string, cooldownTurns: number): boolean {
-    const lastAsked = this.lastAskedTurn.get(conflictId);
-    if (lastAsked === undefined) return true;
-    return this.turnCounter - lastAsked >= cooldownTurns;
-  }
-
-  private wasRecentlyAsked(conflictId: string, cooldownTurns: number): boolean {
-    const lastAsked = this.lastAskedTurn.get(conflictId);
-    if (lastAsked === undefined) return false;
-    return this.turnCounter - lastAsked <= cooldownTurns;
-  }
-
   /**
    * Returns a dismissal reason if the conflict should be dismissed, or null if actionable.
    */
@@ -211,18 +151,17 @@ export class ConflictGate {
     ) {
       return "Dismissed by conflict policy (incoherent — zero statement overlap).";
     }
+    // Dismiss conflicts where neither side has user-evidenced provenance
+    if (
+      !isConflictUserEvidenced(
+        conflict.existingVerificationState,
+        conflict.candidateVerificationState,
+      )
+    ) {
+      return "Dismissed by conflict policy (no user-evidenced provenance).";
+    }
     return null;
   }
 }
 
-export function buildFallbackConflictQuestion(
-  conflict: PendingConflictDetail,
-): string {
-  return [
-    "I have two conflicting notes and need your confirmation.",
-    `A) ${conflict.existingStatement}`,
-    `B) ${conflict.candidateStatement}`,
-    "Which one should I keep?",
-  ].join("\n");
-}
 export { computeConflictRelevance, looksLikeClarificationReply };

package/src/daemon/session-error.ts

@@ -188,6 +188,24 @@ function classifyCore(
           retryable: false,
         };
       }
+      if (/credit balance is too low|insufficient.*credits?/i.test(message)) {
+        return {
+          code: "PROVIDER_BILLING",
+          userMessage: "Your API key has insufficient credits.",
+          retryable: false,
+        };
+      }
+      if (
+        /invalid.*api.?key|invalid.*x-api-key|authentication.?error|invalid.authentication/i.test(
+          message,
+        )
+      ) {
+        return {
+          code: "PROVIDER_BILLING",
+          userMessage: "Your API key is invalid.",
+          retryable: false,
+        };
+      }
       return {
         code: "PROVIDER_API",
         userMessage: "The AI provider rejected the request.",

package/src/daemon/session-lifecycle.ts

@@ -13,7 +13,10 @@ 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 { ContentBlock, Message } from "../providers/types.js";
-import type { TrustClass } from "../runtime/actor-trust-resolver.js";
+import {
+  isUntrustedTrustClass,
+  type TrustClass,
+} from "../runtime/actor-trust-resolver.js";
 import { unregisterSessionSender } from "../tools/browser/browser-screencast.js";
 import { getLogger } from "../util/logger.js";
 import { repairHistory } from "./history-repair.js";
@@ -47,10 +50,6 @@ function parseProvenanceTrustClass(
   return undefined;
 }
 
-function isUntrustedTrustClass(trustClass: TrustClass | undefined): boolean {
-  return trustClass === "trusted_contact" || trustClass === "unknown";
-}
-
 function filterMessagesForUntrustedActor(
   messages: conversationStore.MessageRow[],
 ): conversationStore.MessageRow[] {

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

@@ -19,15 +19,29 @@ export function stripMediaPayloadsForRetry(messages: Message[]): {
   latestUserIndex: number | null;
 } {
   let latestUserIndex: number | null = null;
+  let lastSummaryUserIndex: 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;
+    if (getSummaryFromContextMessage(msg) != null) {
+      // Track the last summary message as a fallback — after aggressive
+      // compaction (minKeepRecentUserTurns: 0), the summary may be the only
+      // user message left and it can contain preserved image blocks that
+      // should not be stripped.
+      if (lastSummaryUserIndex == null) lastSummaryUserIndex = i;
+      continue;
+    }
     latestUserIndex = i;
     break;
   }
 
+  // Fall back to the summary message when compaction consumed all user turns,
+  // so images preserved by compaction are not unconditionally stripped.
+  if (latestUserIndex == null && lastSummaryUserIndex != null) {
+    latestUserIndex = lastSummaryUserIndex;
+  }
+
   let modified = false;
   let replacedBlocks = 0;
   let keptLatestMediaBlocks = 0;

package/src/daemon/session-memory.ts

@@ -24,7 +24,6 @@ export interface MemoryRecallResult {
   runMessages: Message[];
   recall: Awaited<ReturnType<typeof buildMemoryRecall>>;
   dynamicProfile: { text: string };
-  softConflictInstruction: string | null;
   recallInjectionStrategy: RecallInjectionStrategy;
 }
 
@@ -37,7 +36,7 @@ export interface MemoryPrepareContext {
   scopeId: string;
   includeDefaultFallback: boolean;
   trustClass: "guardian" | "trusted_contact" | "unknown";
-  /** When false (e.g. scheduled tasks), skip conflict clarification prompts. */
+  /** When false (e.g. scheduled tasks), skip conflict gate evaluation. */
   isInteractive?: boolean;
 }
 
@@ -64,7 +63,7 @@ export async function prepareMemoryContext(
   userMessageId: string,
   abortSignal: AbortSignal,
   onEvent: (msg: ServerMessage) => void,
-): Promise<MemoryRecallResult & { conflictClarification: string | null }> {
+): Promise<MemoryRecallResult> {
   // Provenance-based trust gating: untrusted actors skip all memory operations
   // (recall, dynamic profile, conflict gate) to prevent untrusted content from
   // influencing memory-augmented responses.
@@ -94,9 +93,7 @@ export async function prepareMemoryContext(
         topCandidates: [],
       } as Awaited<ReturnType<typeof buildMemoryRecall>>,
       dynamicProfile: { text: "" },
-      softConflictInstruction: null,
       recallInjectionStrategy: "prepend_user_block",
-      conflictClarification: null,
     };
   }
 
@@ -129,65 +126,25 @@ export async function prepareMemoryContext(
         topCandidates: [],
       } as Awaited<ReturnType<typeof buildMemoryRecall>>,
       dynamicProfile: { text: "" },
-      softConflictInstruction: null,
       recallInjectionStrategy: "prepend_user_block",
-      conflictClarification: null,
     };
   }
 
   const runtimeConfig = getConfig();
   const memoryEnabled = runtimeConfig.memory?.enabled !== false;
 
-  // Conflict gate — skip entirely for non-interactive sessions (scheduled tasks,
-  // work items) since there is no human to answer the clarification question.
+  // Conflict gate — evaluate for side effects (background resolution/dismissal)
+  // but do not return any user-facing payload. Non-interactive sessions skip
+  // entirely since there is no human context for conflict evaluation.
   const isInteractive = ctx.isInteractive !== false;
   const conflictConfig =
     memoryEnabled && isInteractive
       ? runtimeConfig.memory?.conflicts
       : undefined;
-  const conflictGateResult = conflictConfig
-    ? await ctx.conflictGate.evaluate(content, conflictConfig, ctx.scopeId)
-    : null;
-
-  if (conflictGateResult?.relevant) {
-    return {
-      runMessages: ctx.messages,
-      recall: {
-        enabled: false,
-        degraded: false,
-        injectedText: "",
-        lexicalHits: 0,
-        semanticHits: 0,
-        recencyHits: 0,
-        entityHits: 0,
-        relationSeedEntityCount: 0,
-        relationTraversedEdgeCount: 0,
-        relationNeighborEntityCount: 0,
-        relationExpandedItemCount: 0,
-        earlyTerminated: false,
-        mergedCount: 0,
-        selectedCount: 0,
-        rerankApplied: false,
-        injectedTokens: 0,
-        latencyMs: 0,
-        topCandidates: [],
-      } as Awaited<ReturnType<typeof buildMemoryRecall>>,
-      dynamicProfile: { text: "" },
-      softConflictInstruction: null,
-      recallInjectionStrategy: "prepend_user_block",
-      conflictClarification: [
-        conflictGateResult.question,
-        "",
-        "I need this clarification before I can give guidance that depends on that preference.",
-      ].join("\n"),
-    };
+  if (conflictConfig) {
+    await ctx.conflictGate.evaluate(content, conflictConfig, ctx.scopeId);
   }
 
-  const softConflictInstruction =
-    conflictGateResult && !conflictGateResult.relevant
-      ? conflictGateResult.question
-      : null;
-
   // Dynamic profile
   const profileConfig = memoryEnabled
     ? runtimeConfig.memory?.profile
@@ -312,8 +269,6 @@ export async function prepareMemoryContext(
     runMessages,
     recall,
     dynamicProfile,
-    softConflictInstruction,
     recallInjectionStrategy,
-    conflictClarification: null,
   };
 }

package/src/daemon/session-process.ts

@@ -541,7 +541,9 @@ export async function processMessage(
       messageText: trimmedContent,
       channel: "vellum",
       actor: {
-        externalUserId: session.trustContext?.guardianExternalUserId,
+        actorPrincipalId:
+          session.trustContext?.guardianPrincipalId ?? undefined,
+        actorExternalUserId: session.trustContext?.guardianExternalUserId,
         channel: "vellum",
         guardianPrincipalId:
           session.trustContext?.guardianPrincipalId ?? undefined,

package/src/daemon/session-runtime-assembly.ts

@@ -115,6 +115,10 @@ export interface InboundActorContext {
   memberPolicy?: string;
   /** Denial reason when access is blocked. */
   denialReason?: string;
+  /** Free-text notes about this contact. */
+  contactNotes?: string;
+  /** Number of prior interactions with this contact. */
+  contactInteractionCount?: number;
 }
 
 /**
@@ -159,6 +163,9 @@ export function inboundActorContextFromTrust(
       : undefined,
     memberPolicy: ctx.memberRecord?.channel.policy ?? undefined,
     denialReason: ctx.denialReason,
+    contactNotes: ctx.memberRecord?.contact.notes ?? undefined,
+    contactInteractionCount:
+      ctx.memberRecord?.contact.interactionCount ?? undefined,
   };
 }
 
@@ -392,24 +399,6 @@ export interface ActiveSurfaceContext {
   appFiles?: string[];
 }
 
-/**
- * Append a memory-conflict clarification instruction to the last user message.
- */
-export function injectClarificationRequestIntoUserMessage(
-  message: Message,
-  question: string,
-): Message {
-  const instruction = [
-    "[Memory clarification request]",
-    `Ask this once in your response: ${question}`,
-    "After asking, continue helping with the current request.",
-  ].join("\n");
-  return {
-    ...message,
-    content: [...message.content, { type: "text", text: `\n\n${instruction}` }],
-  };
-}
-
 const MAX_CONTEXT_LENGTH = 100_000;
 
 function truncateHtml(html: string, budget: number): string {
@@ -791,6 +780,14 @@ export function buildInboundActorContextBlock(
     lines.push(`member_policy: ${ctx.memberPolicy}`);
   }
   lines.push(`denial_reason: ${ctx.denialReason ?? "none"}`);
+  // Contact metadata — only included when the sender has a contact record
+  // with non-default values.
+  if (ctx.contactNotes) {
+    lines.push(`contact_notes: ${ctx.contactNotes}`);
+  }
+  if (ctx.contactInteractionCount != null && ctx.contactInteractionCount > 0) {
+    lines.push(`contact_interaction_count: ${ctx.contactInteractionCount}`);
+  }
   if (
     ctx.actorMemberDisplayName &&
     ctx.actorSenderDisplayName &&
@@ -1050,9 +1047,9 @@ export function stripInjectedContext(
  * - `'full'` (default): all injections are applied.
  * - `'minimal'`: only safety-critical context is injected (channel turn,
  *   interface turn, inbound actor, non-interactive marker, voice call
- *   control, channel capabilities, soft conflict). High-token optional
- *   blocks (workspace top-level, temporal, channel command, active surface)
- *   are skipped to reduce context pressure.
+ *   control, channel capabilities). High-token optional blocks (workspace
+ *   top-level, temporal, channel command, active surface) are skipped to
+ *   reduce context pressure.
  */
 export type InjectionMode = "full" | "minimal";
 
@@ -1065,7 +1062,6 @@ export type InjectionMode = "full" | "minimal";
 export function applyRuntimeInjections(
   runMessages: Message[],
   options: {
-    softConflictInstruction?: string | null;
     activeSurface?: ActiveSurfaceContext | null;
     workspaceTopLevelContext?: string | null;
     channelCapabilities?: ChannelCapabilities | null;
@@ -1113,19 +1109,6 @@ export function applyRuntimeInjections(
     }
   }
 
-  if (options.softConflictInstruction) {
-    const userTail = result[result.length - 1];
-    if (userTail && userTail.role === "user") {
-      result = [
-        ...result.slice(0, -1),
-        injectClarificationRequestIntoUserMessage(
-          userTail,
-          options.softConflictInstruction,
-        ),
-      ];
-    }
-  }
-
   if (mode === "full" && options.activeSurface) {
     const userTail = result[result.length - 1];
     if (userTail && userTail.role === "user") {

package/src/daemon/session-surfaces.ts

@@ -1119,7 +1119,6 @@ export async function surfaceProxyResolver(
     const surfaceData: DynamicPageSurfaceData = {
       html: app.htmlDefinition,
       appId: app.id,
-      appType: app.appType,
       preview: {
         ...defaultPreview,
         ...preview,

package/src/daemon/session-tool-setup.ts

@@ -7,10 +7,7 @@
  */
 
 import { isHttpAuthDisabled } from "../config/env.js";
-import type {
-  ProxyApprovalCallback,
-  ProxyApprovalRequest,
-} from "../outbound-proxy/index.js";
+import { getBindingByConversation } from "../memory/external-conversation-store.js";
 import {
   generateAllowlistOptions,
   generateScopeOptions,
@@ -32,6 +29,8 @@ import { requestComputerControlTool } from "../tools/computer-use/request-comput
 import type { ToolExecutor } from "../tools/executor.js";
 import { getAllToolDefinitions } from "../tools/registry.js";
 import type {
+  ProxyApprovalCallback,
+  ProxyApprovalRequest,
   ToolExecutionResult,
   ToolLifecycleEventHandler,
 } from "../tools/types.js";
@@ -163,6 +162,10 @@ export function createToolExecutor(
         ctx.surfaceActionRequestIds?.has(ctx.currentRequestId ?? "") ?? false,
       requesterExternalUserId: ctx.trustContext?.requesterExternalUserId,
       requesterChatId: ctx.trustContext?.requesterChatId,
+      channelPermissionChannelId:
+        ctx.trustContext?.sourceChannel === "slack"
+          ? getBindingByConversation(ctx.conversationId)?.externalChatId
+          : undefined,
       onOutput,
       signal: ctx.abortController?.signal,
       sandboxOverride: ctx.sandboxOverride,

package/src/events/domain-events.ts

@@ -26,7 +26,8 @@ export interface ToolDomainEvents {
       | "allow_thread"
       | "always_allow"
       | "deny"
-      | "always_deny";
+      | "always_deny"
+      | "temporary_override";
     riskLevel: string;
     decidedAtMs: number;
   };

package/src/heartbeat/heartbeat-service.ts

@@ -79,7 +79,11 @@ export class HeartbeatService {
 
     // Active hours guard — only applied when both bounds are set.
     // The schema rejects configs where only one bound is provided.
-    if (!force && config.activeHoursStart != null && config.activeHoursEnd != null) {
+    if (
+      !force &&
+      config.activeHoursStart != null &&
+      config.activeHoursEnd != null
+    ) {
       const hour = this.deps.getCurrentHour?.() ?? new Date().getHours();
       if (
         !isWithinActiveHours(

package/src/home-base/prebuilt/seed.ts

@@ -115,7 +115,6 @@ export function ensurePrebuiltHomeBaseSeeded(): {
     description: buildDescription(metadata),
     schemaJson: "{}",
     htmlDefinition: html,
-    appType: "app",
   });
 
   log.info({ appId: created.id }, "Seeded prebuilt Home Base app");