@vellumai/assistant 0.4.41 → 0.4.43

package/src/memory/{guardian-verification.ts → channel-verification-sessions.ts}

@@ -1,21 +1,25 @@
 /**
- * Guardian verification challenge and session management.
+ * Channel verification session management.
  *
- * Verification challenges track the cryptographic handshake used to prove
- * guardian identity. Sessions extend challenges with outbound identity-bound
- * delivery tracking.
+ * Verification sessions track the cryptographic handshake used to prove
+ * identity. Inbound sessions handle challenge-response verification;
+ * outbound sessions extend with identity-bound delivery tracking.
  */
 
 import { and, count, desc, eq, gt, gte, inArray, or } from "drizzle-orm";
 
 import { getDb } from "./db.js";
-import { channelGuardianVerificationChallenges } from "./schema.js";
+import { channelVerificationSessions } from "./schema.js";
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
-export type ChallengeStatus = "pending" | "consumed" | "expired" | "revoked";
+export type InboundSessionStatus =
+  | "pending"
+  | "consumed"
+  | "expired"
+  | "revoked";
 export type SessionStatus =
   | "pending"
   | "consumed"
@@ -28,7 +32,28 @@ export type SessionStatus =
 export type IdentityBindingStatus = "pending_bootstrap" | "bound";
 export type VerificationPurpose = "guardian" | "trusted_contact";
 
-export interface VerificationChallenge {
+// ---------------------------------------------------------------------------
+// Guardian binding types
+// ---------------------------------------------------------------------------
+
+export type BindingStatus = "active" | "revoked";
+
+export interface GuardianBinding {
+  id: string;
+  assistantId: string;
+  channel: string;
+  guardianExternalUserId: string;
+  guardianDeliveryChatId: string;
+  guardianPrincipalId: string;
+  status: BindingStatus;
+  verifiedAt: number;
+  verifiedVia: string;
+  metadataJson: string | null;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface VerificationSession {
   id: string;
   channel: string;
   challengeHash: string;
@@ -62,9 +87,9 @@ export interface VerificationChallenge {
 // Helpers
 // ---------------------------------------------------------------------------
 
-function rowToChallenge(
-  row: typeof channelGuardianVerificationChallenges.$inferSelect,
-): VerificationChallenge {
+function rowToSession(
+  row: typeof channelVerificationSessions.$inferSelect,
+): VerificationSession {
   return {
     id: row.id,
     channel: row.channel,
@@ -94,27 +119,27 @@ function rowToChallenge(
 }
 
 // ---------------------------------------------------------------------------
-// Verification Challenges
+// Inbound Verification Sessions
 // ---------------------------------------------------------------------------
 
-export function createChallenge(params: {
+export function createInboundSession(params: {
   id: string;
   channel: string;
   challengeHash: string;
   expiresAt: number;
   createdBySessionId?: string;
-}): VerificationChallenge {
+}): VerificationSession {
   const db = getDb();
   const now = Date.now();
 
-  // Revoke any prior pending challenges for the same channel
-  // to close the replay window — only the latest challenge should be valid.
-  db.update(channelGuardianVerificationChallenges)
+  // Revoke any prior pending sessions for the same channel
+  // to close the replay window — only the latest session should be valid.
+  db.update(channelVerificationSessions)
     .set({ status: "revoked", updatedAt: now })
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, params.channel),
-        eq(channelGuardianVerificationChallenges.status, "pending"),
+        eq(channelVerificationSessions.channel, params.channel),
+        eq(channelVerificationSessions.status, "pending"),
       ),
     )
     .run();
@@ -131,7 +156,7 @@ export function createChallenge(params: {
     expectedExternalUserId: null,
     expectedChatId: null,
     expectedPhoneE164: null,
-    identityBindingStatus: "bound" as const,
+    identityBindingStatus: null,
     destinationAddress: null,
     lastSentAt: null,
     sendCount: 0,
@@ -144,82 +169,82 @@ export function createChallenge(params: {
     updatedAt: now,
   };
 
-  db.insert(channelGuardianVerificationChallenges).values(row).run();
+  db.insert(channelVerificationSessions).values(row).run();
 
-  return rowToChallenge(row);
+  return rowToSession(row);
 }
 
-export function revokePendingChallenges(channel: string): void {
+export function revokePendingSessions(channel: string): void {
   const db = getDb();
-  db.update(channelGuardianVerificationChallenges)
+  db.update(channelVerificationSessions)
     .set({ status: "revoked", updatedAt: Date.now() })
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, channel),
-        eq(channelGuardianVerificationChallenges.status, "pending"),
+        eq(channelVerificationSessions.channel, channel),
+        eq(channelVerificationSessions.status, "pending"),
       ),
     )
     .run();
 }
 
-export function findPendingChallengeByHash(
+export function findPendingSessionByHash(
   channel: string,
   challengeHash: string,
-): VerificationChallenge | null {
+): VerificationSession | null {
   const db = getDb();
   const now = Date.now();
 
   // Match any consumable status: 'pending' (inbound), 'pending_bootstrap', 'awaiting_response' (outbound)
   const row = db
     .select()
-    .from(channelGuardianVerificationChallenges)
+    .from(channelVerificationSessions)
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, channel),
-        eq(channelGuardianVerificationChallenges.challengeHash, challengeHash),
-        inArray(channelGuardianVerificationChallenges.status, [
+        eq(channelVerificationSessions.channel, channel),
+        eq(channelVerificationSessions.challengeHash, challengeHash),
+        inArray(channelVerificationSessions.status, [
           "pending",
           "pending_bootstrap",
           "awaiting_response",
         ]),
-        gt(channelGuardianVerificationChallenges.expiresAt, now),
+        gt(channelVerificationSessions.expiresAt, now),
       ),
     )
     .get();
 
-  return row ? rowToChallenge(row) : null;
+  return row ? rowToSession(row) : null;
 }
 
 /**
- * Find any pending inbound (non-expired) challenge for a given channel.
+ * Find any pending inbound (non-expired) session for a given channel.
  * Scoped to 'pending' status only — this is the inbound verification path used by
  * the relay-server to gate incoming voice calls. Outbound session states
  * (pending_bootstrap, awaiting_response) are excluded so that an active outbound
  * verification does not inadvertently force unrelated inbound callers into the
- * guardian verification flow.
+ * verification flow.
  */
-export function findPendingChallengeForChannel(
+export function findPendingSessionForChannel(
   channel: string,
-): VerificationChallenge | null {
+): VerificationSession | null {
   const db = getDb();
   const now = Date.now();
 
   const row = db
     .select()
-    .from(channelGuardianVerificationChallenges)
+    .from(channelVerificationSessions)
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, channel),
-        eq(channelGuardianVerificationChallenges.status, "pending"),
-        gt(channelGuardianVerificationChallenges.expiresAt, now),
+        eq(channelVerificationSessions.channel, channel),
+        eq(channelVerificationSessions.status, "pending"),
+        gt(channelVerificationSessions.expiresAt, now),
       ),
     )
     .get();
 
-  return row ? rowToChallenge(row) : null;
+  return row ? rowToSession(row) : null;
 }
 
-export function consumeChallenge(
+export function consumeSession(
   id: string,
   consumedByExternalUserId: string,
   consumedByChatId: string,
@@ -227,14 +252,14 @@ export function consumeChallenge(
   const db = getDb();
   const now = Date.now();
 
-  db.update(channelGuardianVerificationChallenges)
+  db.update(channelVerificationSessions)
     .set({
       status: "consumed",
       consumedByExternalUserId,
       consumedByChatId,
       updatedAt: now,
     })
-    .where(eq(channelGuardianVerificationChallenges.id, id))
+    .where(eq(channelVerificationSessions.id, id))
     .run();
 }
 
@@ -263,17 +288,17 @@ export function createVerificationSession(params: {
   maxAttempts?: number;
   verificationPurpose?: VerificationPurpose;
   bootstrapTokenHash?: string | null;
-}): VerificationChallenge {
+}): VerificationSession {
   const db = getDb();
   const now = Date.now();
 
   // Revoke any prior pending/awaiting_response sessions for the same channel
-  db.update(channelGuardianVerificationChallenges)
+  db.update(channelVerificationSessions)
     .set({ status: "revoked", updatedAt: now })
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, params.channel),
-        inArray(channelGuardianVerificationChallenges.status, [
+        eq(channelVerificationSessions.channel, params.channel),
+        inArray(channelVerificationSessions.status, [
           "pending",
           "pending_bootstrap",
           "awaiting_response",
@@ -307,38 +332,36 @@ export function createVerificationSession(params: {
     updatedAt: now,
   };
 
-  db.insert(channelGuardianVerificationChallenges).values(row).run();
+  db.insert(channelVerificationSessions).values(row).run();
 
-  return rowToChallenge(row);
+  return rowToSession(row);
 }
 
 /**
  * Find the most recent pending_bootstrap or awaiting_response session
  * for a given channel.
  */
-export function findActiveSession(
-  channel: string,
-): VerificationChallenge | null {
+export function findActiveSession(channel: string): VerificationSession | null {
   const db = getDb();
   const now = Date.now();
 
   const row = db
     .select()
-    .from(channelGuardianVerificationChallenges)
+    .from(channelVerificationSessions)
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, channel),
-        inArray(channelGuardianVerificationChallenges.status, [
+        eq(channelVerificationSessions.channel, channel),
+        inArray(channelVerificationSessions.status, [
           "pending_bootstrap",
           "awaiting_response",
         ]),
-        gt(channelGuardianVerificationChallenges.expiresAt, now),
+        gt(channelVerificationSessions.expiresAt, now),
       ),
     )
-    .orderBy(desc(channelGuardianVerificationChallenges.createdAt))
+    .orderBy(desc(channelVerificationSessions.createdAt))
     .get();
 
-  return row ? rowToChallenge(row) : null;
+  return row ? rowToSession(row) : null;
 }
 
 /**
@@ -348,24 +371,24 @@ export function findActiveSession(
 export function findSessionByBootstrapTokenHash(
   channel: string,
   tokenHash: string,
-): VerificationChallenge | null {
+): VerificationSession | null {
   const db = getDb();
   const now = Date.now();
 
   const row = db
     .select()
-    .from(channelGuardianVerificationChallenges)
+    .from(channelVerificationSessions)
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, channel),
-        eq(channelGuardianVerificationChallenges.bootstrapTokenHash, tokenHash),
-        eq(channelGuardianVerificationChallenges.status, "pending_bootstrap"),
-        gt(channelGuardianVerificationChallenges.expiresAt, now),
+        eq(channelVerificationSessions.channel, channel),
+        eq(channelVerificationSessions.bootstrapTokenHash, tokenHash),
+        eq(channelVerificationSessions.status, "pending_bootstrap"),
+        gt(channelVerificationSessions.expiresAt, now),
       ),
     )
     .get();
 
-  return row ? rowToChallenge(row) : null;
+  return row ? rowToSession(row) : null;
 }
 
 /**
@@ -377,7 +400,7 @@ export function findSessionByIdentity(
   externalUserId?: string,
   chatId?: string,
   phoneE164?: string,
-): VerificationChallenge | null {
+): VerificationSession | null {
   // Require at least one identity parameter to avoid accidentally matching
   // an unrelated session when the caller has no parsed identity fields.
   if (!externalUserId && !chatId && !phoneE164) {
@@ -388,32 +411,29 @@ export function findSessionByIdentity(
   const now = Date.now();
 
   const conditions = [
-    eq(channelGuardianVerificationChallenges.channel, channel),
-    inArray(channelGuardianVerificationChallenges.status, [
+    eq(channelVerificationSessions.channel, channel),
+    inArray(channelVerificationSessions.status, [
       "pending_bootstrap",
       "awaiting_response",
     ]),
-    gt(channelGuardianVerificationChallenges.expiresAt, now),
+    gt(channelVerificationSessions.expiresAt, now),
   ];
 
   // Build identity match conditions
   const identityConditions = [];
   if (externalUserId) {
     identityConditions.push(
-      eq(
-        channelGuardianVerificationChallenges.expectedExternalUserId,
-        externalUserId,
-      ),
+      eq(channelVerificationSessions.expectedExternalUserId, externalUserId),
     );
   }
   if (chatId) {
     identityConditions.push(
-      eq(channelGuardianVerificationChallenges.expectedChatId, chatId),
+      eq(channelVerificationSessions.expectedChatId, chatId),
     );
   }
   if (phoneE164) {
     identityConditions.push(
-      eq(channelGuardianVerificationChallenges.expectedPhoneE164, phoneE164),
+      eq(channelVerificationSessions.expectedPhoneE164, phoneE164),
     );
   }
 
@@ -423,12 +443,12 @@ export function findSessionByIdentity(
 
   const row = db
     .select()
-    .from(channelGuardianVerificationChallenges)
+    .from(channelVerificationSessions)
     .where(and(...conditions))
-    .orderBy(desc(channelGuardianVerificationChallenges.createdAt))
+    .orderBy(desc(channelVerificationSessions.createdAt))
     .get();
 
-  return row ? rowToChallenge(row) : null;
+  return row ? rowToSession(row) : null;
 }
 
 /**
@@ -445,7 +465,7 @@ export function updateSessionStatus(
   const db = getDb();
   const now = Date.now();
 
-  db.update(channelGuardianVerificationChallenges)
+  db.update(channelVerificationSessions)
     .set({
       status,
       updatedAt: now,
@@ -456,7 +476,7 @@ export function updateSessionStatus(
         ? { consumedByChatId: extraFields.consumedByChatId }
         : {}),
     })
-    .where(eq(channelGuardianVerificationChallenges.id, id))
+    .where(eq(channelVerificationSessions.id, id))
     .run();
 }
 
@@ -472,14 +492,14 @@ export function updateSessionDelivery(
   const db = getDb();
   const now = Date.now();
 
-  db.update(channelGuardianVerificationChallenges)
+  db.update(channelVerificationSessions)
     .set({
       lastSentAt,
       sendCount,
       nextResendAt,
       updatedAt: now,
     })
-    .where(eq(channelGuardianVerificationChallenges.id, id))
+    .where(eq(channelVerificationSessions.id, id))
     .run();
 }
 
@@ -500,15 +520,12 @@ export function countRecentSendsToDestination(
 
   const result = db
     .select({ total: count() })
-    .from(channelGuardianVerificationChallenges)
+    .from(channelVerificationSessions)
     .where(
       and(
-        eq(channelGuardianVerificationChallenges.channel, channel),
-        eq(
-          channelGuardianVerificationChallenges.destinationAddress,
-          destinationAddress,
-        ),
-        gte(channelGuardianVerificationChallenges.lastSentAt, cutoff),
+        eq(channelVerificationSessions.channel, channel),
+        eq(channelVerificationSessions.destinationAddress, destinationAddress),
+        gte(channelVerificationSessions.lastSentAt, cutoff),
       ),
     )
     .get();
@@ -528,13 +545,13 @@ export function bindSessionIdentity(
   const db = getDb();
   const now = Date.now();
 
-  db.update(channelGuardianVerificationChallenges)
+  db.update(channelVerificationSessions)
     .set({
       expectedExternalUserId: externalUserId,
       expectedChatId: chatId,
       identityBindingStatus: "bound",
       updatedAt: now,
     })
-    .where(eq(channelGuardianVerificationChallenges.id, id))
+    .where(eq(channelVerificationSessions.id, id))
     .run();
 }

package/src/memory/conversation-attention-store.ts

@@ -9,6 +9,7 @@
 import { and, desc, eq, inArray, isNull, lt, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { UserError } from "../util/errors.js";
 import { getDb } from "./db.js";
 import {
   conversationAssistantAttentionState,
@@ -22,6 +23,7 @@ import {
 export type SignalType =
   | "macos_notification_view"
   | "macos_conversation_opened"
+  | "ios_conversation_opened"
   | "telegram_inbound_message"
   | "telegram_callback"
   | "slack_inbound_message"
@@ -303,6 +305,158 @@ export function recordConversationSeenSignal(params: {
   return rowToEvent(event as typeof conversationAttentionEvents.$inferSelect);
 }
 
+// ── markConversationUnread ───────────────────────────────────────────
+
+function resolveAssistantCursor(params: {
+  db: Pick<ReturnType<typeof getDb>, "select">;
+  conversationId: string;
+  latestAssistantMessageId?: string | null;
+  latestAssistantMessageAt?: number | null;
+}): {
+  latestAssistantMessageId: string;
+  latestAssistantMessageAt: number;
+  previousAssistantMessageId: string | null;
+  previousAssistantMessageAt: number | null;
+} | null {
+  const {
+    db,
+    conversationId,
+    latestAssistantMessageId,
+    latestAssistantMessageAt,
+  } = params;
+
+  // Unread classification compares timestamps strictly, so rewinding to a
+  // same-timestamp sibling would leave the latest reply classified as seen.
+  const previousAssistantMessageBefore = (before: number) =>
+    db
+      .select({ id: messages.id, createdAt: messages.createdAt })
+      .from(messages)
+      .where(
+        and(
+          eq(messages.conversationId, conversationId),
+          eq(messages.role, "assistant"),
+          lt(messages.createdAt, before),
+        ),
+      )
+      .orderBy(desc(messages.createdAt), desc(messages.id))
+      .limit(1)
+      .get();
+
+  if (latestAssistantMessageId && latestAssistantMessageAt != null) {
+    const previousMessage = previousAssistantMessageBefore(
+      latestAssistantMessageAt,
+    );
+
+    return {
+      latestAssistantMessageId,
+      latestAssistantMessageAt,
+      previousAssistantMessageId: previousMessage?.id ?? null,
+      previousAssistantMessageAt: previousMessage?.createdAt ?? null,
+    };
+  }
+
+  const latestMessage = db
+    .select({ id: messages.id, createdAt: messages.createdAt })
+    .from(messages)
+    .where(
+      and(
+        eq(messages.conversationId, conversationId),
+        eq(messages.role, "assistant"),
+      ),
+    )
+    .orderBy(desc(messages.createdAt), desc(messages.id))
+    .limit(1)
+    .get();
+
+  if (!latestMessage) {
+    return null;
+  }
+
+  const previousMessage = previousAssistantMessageBefore(
+    latestMessage.createdAt,
+  );
+  return {
+    latestAssistantMessageId: latestMessage.id,
+    latestAssistantMessageAt: latestMessage.createdAt,
+    previousAssistantMessageId: previousMessage?.id ?? null,
+    previousAssistantMessageAt: previousMessage?.createdAt ?? null,
+  };
+}
+
+/**
+ * Rewind the seen cursor so the current latest assistant reply becomes unread.
+ * This uses the existing attention projection instead of adding a separate
+ * manual-unread state machine.
+ */
+export function markConversationUnread(conversationId: string): void {
+  const db = getDb();
+  const now = Date.now();
+
+  db.transaction((tx) => {
+    const state = tx
+      .select()
+      .from(conversationAssistantAttentionState)
+      .where(
+        eq(conversationAssistantAttentionState.conversationId, conversationId),
+      )
+      .get();
+
+    const cursor = resolveAssistantCursor({
+      db: tx,
+      conversationId,
+      latestAssistantMessageId: state?.latestAssistantMessageId,
+      latestAssistantMessageAt: state?.latestAssistantMessageAt,
+    });
+
+    if (!cursor) {
+      throw new UserError(
+        "Conversation has no assistant message to mark unread",
+      );
+    }
+
+    const isAlreadyUnread =
+      state != null &&
+      (state.lastSeenAssistantMessageAt == null ||
+        state.lastSeenAssistantMessageAt < cursor.latestAssistantMessageAt);
+
+    if (isAlreadyUnread) {
+      return;
+    }
+
+    if (!state) {
+      tx.insert(conversationAssistantAttentionState)
+        .values({
+          conversationId,
+          latestAssistantMessageId: cursor.latestAssistantMessageId,
+          latestAssistantMessageAt: cursor.latestAssistantMessageAt,
+          lastSeenAssistantMessageId: cursor.previousAssistantMessageId,
+          lastSeenAssistantMessageAt: cursor.previousAssistantMessageAt,
+          lastSeenEventAt: null,
+          lastSeenConfidence: null,
+          lastSeenSignalType: null,
+          lastSeenSourceChannel: null,
+          lastSeenSource: null,
+          lastSeenEvidenceText: null,
+          createdAt: now,
+          updatedAt: now,
+        })
+        .run();
+      return;
+    }
+
+    tx.update(conversationAssistantAttentionState)
+      .set({
+        lastSeenAssistantMessageId: cursor.previousAssistantMessageId,
+        lastSeenAssistantMessageAt: cursor.previousAssistantMessageAt,
+        updatedAt: now,
+      })
+      .where(
+        eq(conversationAssistantAttentionState.conversationId, conversationId),
+      )
+      .run();
+  });
+}
+
 // ── getAttentionStateByConversationIds ───────────────────────────────
 
 /**

package/src/memory/conversation-bootstrap.ts

@@ -1,4 +1,4 @@
-import { createConversation } from "./conversation-store.js";
+import { createConversation } from "./conversation-crud.js";
 import {
   GENERATING_TITLE,
   queueGenerateConversationTitle,