@vellumai/assistant 0.4.30 → 0.4.31

package/src/contacts/contact-store.ts

@@ -33,10 +33,7 @@ function parseContact(row: typeof contacts.$inferSelect): Contact {
   return {
     id: row.id,
     displayName: row.displayName,
-    relationship: row.relationship,
-    importance: row.importance,
-    responseExpectation: row.responseExpectation,
-    preferredTone: row.preferredTone,
+    notes: row.notes,
     lastInteraction: row.lastInteraction,
     interactionCount: row.interactionCount,
     createdAt: row.createdAt,
@@ -153,10 +150,7 @@ export function getChannelById(channelId: string): ContactChannel | null {
 export function upsertContact(params: {
   id?: string;
   displayName: string;
-  relationship?: string | null;
-  importance?: number;
-  responseExpectation?: string | null;
-  preferredTone?: string | null;
+  notes?: string | null;
   role?: ContactRole;
   contactType?: ContactType;
   principalId?: string | null;
@@ -178,24 +172,9 @@ export function upsertContact(params: {
     if (existing) {
       const updateSet: Record<string, unknown> = {
         displayName: params.displayName,
-        relationship:
-          params.relationship !== undefined
-            ? params.relationship
-            : existing.relationship,
-        importance:
-          params.importance !== undefined
-            ? params.importance
-            : existing.importance,
-        responseExpectation:
-          params.responseExpectation !== undefined
-            ? params.responseExpectation
-            : existing.responseExpectation,
-        preferredTone:
-          params.preferredTone !== undefined
-            ? params.preferredTone
-            : existing.preferredTone,
         updatedAt: now,
       };
+      if (params.notes !== undefined) updateSet.notes = params.notes;
       if (params.role !== undefined) updateSet.role = params.role;
       if (params.contactType !== undefined)
         updateSet.contactType = params.contactType;
@@ -213,6 +192,7 @@ export function upsertContact(params: {
         syncChannels(contactId, params.channels, now);
       }
 
+      emitContactChange();
       return { ...getContactInternal(contactId)!, created: false };
     }
   }
@@ -259,14 +239,7 @@ export function upsertContact(params: {
           displayName: params.displayName,
           updatedAt: now,
         };
-        if (params.relationship !== undefined)
-          updateSet.relationship = params.relationship;
-        if (params.importance !== undefined)
-          updateSet.importance = params.importance;
-        if (params.responseExpectation !== undefined)
-          updateSet.responseExpectation = params.responseExpectation;
-        if (params.preferredTone !== undefined)
-          updateSet.preferredTone = params.preferredTone;
+        if (params.notes !== undefined) updateSet.notes = params.notes;
         if (params.role !== undefined) updateSet.role = params.role;
         if (params.contactType !== undefined)
           updateSet.contactType = params.contactType;
@@ -281,6 +254,7 @@ export function upsertContact(params: {
           .run();
 
         syncChannels(contactId, params.channels, now);
+        emitContactChange();
         return { ...getContactInternal(contactId)!, created: false };
       }
     }
@@ -292,10 +266,7 @@ export function upsertContact(params: {
     .values({
       id: contactId,
       displayName: params.displayName,
-      relationship: params.relationship ?? null,
-      importance: params.importance ?? 0.5,
-      responseExpectation: params.responseExpectation ?? null,
-      preferredTone: params.preferredTone ?? null,
+      notes: params.notes ?? null,
       lastInteraction: null,
       interactionCount: 0,
       role: params.role ?? "contact",
@@ -311,6 +282,7 @@ export function upsertContact(params: {
     syncChannels(contactId, params.channels, now);
   }
 
+  emitContactChange();
   return { ...getContactInternal(contactId)!, created: true };
 }
 
@@ -436,7 +408,6 @@ export function searchContacts(params: {
   query?: string;
   channelAddress?: string;
   channelType?: string;
-  relationship?: string;
   role?: ContactRole;
   contactType?: ContactType;
   limit?: number;
@@ -491,7 +462,7 @@ export function searchContacts(params: {
   }
 
   // Search by channel type alone (no address)
-  if (params.channelType && !params.query && !params.relationship) {
+  if (params.channelType && !params.query) {
     const channelRows = db
       .select({ contactId: contactChannels.contactId })
       .from(contactChannels)
@@ -525,7 +496,7 @@ export function searchContacts(params: {
     return results;
   }
 
-  // Search by display name and/or relationship, optionally filtered by channelType
+  // Search by display name, optionally filtered by channelType
   const conditions = [
     or(
       eq(contacts.assistantId, params.assistantId),
@@ -534,20 +505,11 @@ export function searchContacts(params: {
   ];
   if (params.query) {
     const sanitized = escapeLike(params.query);
-    if (
-      !sanitized &&
-      !params.relationship &&
-      !params.role &&
-      !params.contactType
-    )
-      return [];
+    if (!sanitized && !params.role && !params.contactType) return [];
     if (sanitized) {
       conditions.push(like(contacts.displayName, `%${sanitized}%`));
     }
   }
-  if (params.relationship) {
-    conditions.push(eq(contacts.relationship, params.relationship));
-  }
   if (params.role) {
     conditions.push(eq(contacts.role, params.role));
   }
@@ -569,7 +531,7 @@ export function searchContacts(params: {
       .from(contacts)
       .innerJoin(contactChannels, eq(contacts.id, contactChannels.contactId))
       .where(whereClause)
-      .orderBy(desc(contacts.importance), desc(contacts.lastInteraction))
+      .orderBy(desc(contacts.updatedAt), desc(contacts.lastInteraction))
       .all();
 
     const contactIds = [...new Set(rows.map((r) => r.contactId))];
@@ -590,7 +552,7 @@ export function searchContacts(params: {
     .select()
     .from(contacts)
     .where(whereClause)
-    .orderBy(desc(contacts.importance), desc(contacts.lastInteraction))
+    .orderBy(desc(contacts.updatedAt), desc(contacts.lastInteraction))
     .limit(limit)
     .all();
 
@@ -617,7 +579,7 @@ export function listContacts(
     .where(conditions.length === 1 ? conditions[0] : and(...conditions))
     .orderBy(
       sql`${contacts.role} = 'guardian' DESC`,
-      desc(contacts.importance),
+      desc(contacts.updatedAt),
       desc(contacts.lastInteraction),
     )
     .limit(effectiveLimit)
@@ -626,9 +588,9 @@ export function listContacts(
 }
 
 /**
- * Merge two contacts into one. The surviving contact keeps the higher importance,
- * more recent interaction timestamp, and all channels from both contacts.
- * The donor contact is deleted after merging.
+ * Merge two contacts into one. The surviving contact keeps the
+ * more recent interaction timestamp, concatenated notes, and all channels
+ * from both contacts. The donor contact is deleted after merging.
  */
 export function mergeContacts(
   keepId: string,
@@ -673,7 +635,6 @@ export function mergeContacts(
     if (!merge) throw new Error(`Contact "${mergeId}" not found`);
 
     // Resolve merged field values — pick the better/more recent value
-    const mergedImportance = Math.max(keep.importance, merge.importance);
     const mergedInteractionCount =
       keep.interactionCount + merge.interactionCount;
     const mergedLastInteraction =
@@ -681,14 +642,9 @@ export function mergeContacts(
 
     tx.update(contacts)
       .set({
-        importance: mergedImportance,
         interactionCount: mergedInteractionCount,
         lastInteraction: mergedLastInteraction,
-        // Prefer keep's values, fall back to merge's
-        relationship: keep.relationship ?? merge.relationship,
-        responseExpectation:
-          keep.responseExpectation ?? merge.responseExpectation,
-        preferredTone: keep.preferredTone ?? merge.preferredTone,
+        notes: [keep.notes, merge.notes].filter(Boolean).join("\n") || null,
         updatedAt: now,
         // Rebind legacy null-scoped contacts to prevent cross-assistant leakage
         ...(keep.assistantId == null ? { assistantId } : {}),
@@ -728,6 +684,7 @@ export function mergeContacts(
     tx.delete(contacts).where(eq(contacts.id, mergeId)).run();
   });
 
+  emitContactChange();
   return getContactInternal(keepId)!;
 }
 
@@ -1026,6 +983,23 @@ export function updateChannelLastSeenById(channelId: string): void {
     .run();
 }
 
+/**
+ * Atomically increment interactionCount and set lastInteraction on a contact.
+ * Optimized for the hot path — single UPDATE with no prior SELECT.
+ */
+export function updateContactInteraction(contactId: string): void {
+  const db = getDb();
+  const now = Date.now();
+  db.update(contacts)
+    .set({
+      lastInteraction: now,
+      interactionCount: sql`${contacts.interactionCount} + 1`,
+      updatedAt: now,
+    })
+    .where(eq(contacts.id, contactId))
+    .run();
+}
+
 // ── Assistant Contact Metadata ──────────────────────────────────────
 
 function parseAssistantMetadata(

package/src/contacts/contacts-write.ts

@@ -19,6 +19,7 @@ import {
   getContactInternal,
   updateChannelLastSeenById,
   updateChannelStatus,
+  updateContactInteraction,
   upsertContact,
 } from "./contact-store.js";
 import type {
@@ -78,6 +79,7 @@ export function createGuardianBinding(params: {
   upsertContact({
     displayName,
     role: "guardian",
+    notes: "guardian",
     principalId: params.guardianPrincipalId,
     assistantId: params.assistantId,
     channels: [
@@ -109,7 +111,6 @@ export function createGuardianBinding(params: {
     updatedAt: now,
   };
 
-  emitContactChange();
   return result;
 }
 
@@ -204,8 +205,6 @@ export function upsertMember(params: {
     externalChatId: params.externalChatId,
   });
 
-  emitContactChange();
-
   if (contactResult) {
     return { contact: contactResult.contact, channel: contactResult.channel };
   }
@@ -285,3 +284,15 @@ export function touchChannelLastSeen(channelId: string): void {
     log.warn({ err }, "Failed to update channel lastSeenAt");
   }
 }
+
+/**
+ * Increment the interaction count and update lastInteraction on a contact.
+ * Expects a plain contact UUID (Contact.id).
+ */
+export function touchContactInteraction(contactId: string): void {
+  try {
+    updateContactInteraction(contactId);
+  } catch (err) {
+    log.warn({ err }, "Failed to update contact interaction stats");
+  }
+}

package/src/contacts/types.ts

@@ -28,16 +28,21 @@ export type AssistantContactMetadata =
 export interface Contact {
   id: string;
   displayName: string;
-  relationship: string | null;
-  importance: number;
-  responseExpectation: string | null;
-  preferredTone: string | null;
+  /** Free-text notes about this contact (e.g. relationship, communication preferences). */
+  notes: string | null;
   lastInteraction: number | null;
   interactionCount: number;
   createdAt: number;
   updatedAt: number;
   role: ContactRole;
   contactType: ContactType;
+  /**
+   * Internal auth identity (e.g. "vellum-principal-<uuid>"). Only meaningful
+   * for guardian contacts — it ties the contact record to the auth layer so
+   * the system can verify "this API caller IS this guardian" via JWT
+   * actorPrincipalId. Always null for non-guardian contacts, which are
+   * identified by channel address instead.
+   */
   principalId: string | null;
   assistantId: string | null;
 }

package/src/daemon/handlers/config-heartbeat.ts

@@ -218,8 +218,7 @@ export function handleHeartbeatRunNow(
         ctx.send(socket, {
           type: "heartbeat_run_now_response",
           success: false,
-          error:
-            "Heartbeat skipped (a previous run is still active)",
+          error: "Heartbeat skipped (a previous run is still active)",
         });
       }
     })

package/src/daemon/handlers/contacts.ts

@@ -38,8 +38,8 @@ function toContactPayload(contact: ContactWithChannels): ContactPayload {
     id: contact.id,
     displayName: contact.displayName,
     role: contact.role,
-    relationship: contact.relationship ?? undefined,
-    importance: contact.importance,
+    notes: contact.notes ?? undefined,
+    contactType: contact.contactType ?? undefined,
     lastInteraction: contact.lastInteraction ?? undefined,
     interactionCount: contact.interactionCount,
     channels: contact.channels.map(toChannelPayload),

package/src/daemon/handlers/guardian-actions.ts

@@ -38,7 +38,7 @@ export const guardianActionsHandlers = defineHandlers({
         conversationId: msg.conversationId,
         channel: "vellum",
         actorContext: {
-          externalUserId: localTrustCtx.guardianExternalUserId,
+          actorPrincipalId: localTrustCtx.guardianExternalUserId,
           guardianPrincipalId: localTrustCtx.guardianPrincipalId ?? undefined,
         },
       });

package/src/daemon/handlers/sessions.ts

@@ -895,7 +895,8 @@ export async function handleUserMessage(
             messageText: messageText.trim(),
             channel: ipcChannel,
             actor: {
-              externalUserId: localCtx.guardianExternalUserId,
+              actorPrincipalId: localCtx.guardianPrincipalId ?? undefined,
+              actorExternalUserId: localCtx.guardianExternalUserId,
               channel: ipcChannel,
               guardianPrincipalId: localCtx.guardianPrincipalId ?? undefined,
             },

package/src/daemon/ipc-contract/contacts.ts

@@ -40,8 +40,8 @@ export interface ContactPayload {
   id: string;
   displayName: string;
   role: "guardian" | "contact";
-  relationship?: string;
-  importance: number;
+  notes?: string;
+  contactType?: string;
   lastInteraction?: number;
   interactionCount: number;
   channels: ContactChannelPayload[];

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,

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 };