@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/contacts/contact-store.ts

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, isNotNull, like, sql } from "drizzle-orm";
+import { and, asc, desc, eq, like, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import type { ChannelId } from "../channels/types.js";
@@ -96,13 +96,12 @@ function parseContact(row: typeof contacts.$inferSelect): Contact {
     id: row.id,
     displayName: row.displayName,
     notes: row.notes,
+    role: row.role,
     lastInteraction: null,
     interactionCount: 0,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
-    role: row.role as Contact["role"],
-    contactType: (row.contactType as Contact["contactType"]) ?? "human",
-    principalId: row.principalId,
+    contactType: row.contactType,
     userFile: row.userFile ?? null,
   };
 }
@@ -117,13 +116,7 @@ function parseChannel(
     address: row.address,
     isPrimary: row.isPrimary,
     externalChatId: row.externalChatId,
-    status: row.status as ContactChannel["status"],
-    policy: row.policy as ContactChannel["policy"],
-    verifiedAt: row.verifiedAt,
-    verifiedVia: row.verifiedVia,
     inviteId: row.inviteId,
-    revokedReason: row.revokedReason,
-    blockedReason: row.blockedReason,
     lastSeenAt: row.lastSeenAt,
     interactionCount: row.interactionCount,
     lastInteraction: row.lastInteraction,
@@ -145,6 +138,8 @@ function getChannelsForContact(contactId: string): ContactChannel[] {
 
 function withChannels(contact: Contact): ContactWithChannels {
   const channels = getChannelsForContact(contact.id);
+  // INFO telemetry aggregated from channel rows (not ACL): sum interaction
+  // counts, take the most recent interaction across channels.
   const interactionCount = channels.reduce(
     (sum, ch) => sum + ch.interactionCount,
     0,
@@ -225,7 +220,6 @@ export function upsertContact(params: {
   notes?: string | null;
   role?: ContactRole;
   contactType?: ContactType;
-  principalId?: string | null;
   userFile?: string | null;
   channels?: SyncChannelData[];
   /** When true, conflicting channels on other contacts are reassigned to this
@@ -260,11 +254,8 @@ export function upsertContact(params: {
         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;
-      if (params.principalId !== undefined)
-        updateSet.principalId = params.principalId;
       if (params.userFile !== undefined) updateSet.userFile = params.userFile;
 
       db.update(contacts)
@@ -298,11 +289,8 @@ export function upsertContact(params: {
           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;
-        if (params.principalId !== undefined)
-          updateSet.principalId = params.principalId;
         if (params.userFile !== undefined) updateSet.userFile = params.userFile;
 
         db.update(contacts)
@@ -319,35 +307,16 @@ export function upsertContact(params: {
 
   // Create new contact
   contactId = contactId ?? uuid();
-  // Sibling contacts sharing a principal_id must share a user_file so every
-  // channel for one principal resolves to the same persona + journal slug.
-  let resolvedUserFile: string | null;
-  if (params.userFile !== undefined) {
-    resolvedUserFile = params.userFile;
-  } else if (params.principalId) {
-    const sibling = db
-      .select({ userFile: contacts.userFile })
-      .from(contacts)
-      .where(
-        and(
-          eq(contacts.principalId, params.principalId),
-          isNotNull(contacts.userFile),
-        ),
-      )
-      .get();
-    resolvedUserFile =
-      sibling?.userFile ?? generateUserFileSlug(params.displayName);
-  } else {
-    resolvedUserFile = generateUserFileSlug(params.displayName);
-  }
+  const resolvedUserFile =
+    params.userFile !== undefined
+      ? params.userFile
+      : generateUserFileSlug(params.displayName);
   db.insert(contacts)
     .values({
       id: contactId,
       displayName: params.displayName,
       notes: params.notes ?? null,
-      role: params.role ?? "contact",
       contactType: params.contactType ?? "human",
-      principalId: params.principalId ?? null,
       userFile: resolvedUserFile,
       createdAt: now,
       updatedAt: now,
@@ -396,27 +365,12 @@ function syncChannels(
       .get();
 
     if (existing) {
-      // Preserve guardian blocks: if the channel is blocked, do not overwrite
-      // its status/policy — mirrors the guard in the cross-contact reassignment
-      // path so a blocked channel cannot be unblocked via a same-contact sync.
-      const isBlocked = existing.status === "blocked";
-
       const updateSet: Record<string, unknown> = {};
       // Self-heal legacy lowercased addresses to canonical form.
       if (existing.address !== ch.address) updateSet.address = ch.address;
       if (ch.isPrimary !== undefined) updateSet.isPrimary = ch.isPrimary;
       if (ch.externalChatId !== undefined)
         updateSet.externalChatId = ch.externalChatId;
-      if (!isBlocked) {
-        if (ch.status !== undefined) updateSet.status = ch.status;
-        if (ch.policy !== undefined) updateSet.policy = ch.policy;
-        if (ch.revokedReason !== undefined)
-          updateSet.revokedReason = ch.revokedReason;
-        if (ch.blockedReason !== undefined)
-          updateSet.blockedReason = ch.blockedReason;
-      }
-      if (ch.verifiedAt !== undefined) updateSet.verifiedAt = ch.verifiedAt;
-      if (ch.verifiedVia !== undefined) updateSet.verifiedVia = ch.verifiedVia;
       if (ch.inviteId !== undefined) updateSet.inviteId = ch.inviteId;
 
       if (Object.keys(updateSet).length > 0) {
@@ -434,11 +388,6 @@ function syncChannels(
 
     if (conflicting) {
       if (reassignConflicting) {
-        // Preserve guardian blocks: if the existing channel is blocked, do not
-        // overwrite its status/policy — a valid invite must not bypass an
-        // explicit guardian block on a different contact.
-        const isBlocked = conflicting.status === "blocked";
-
         // Reassign the channel to the target contact. Used by invite redemption
         // to bind a redeemer's existing channel identity to the invite's target.
         const reassignSet: Record<string, unknown> = {
@@ -447,17 +396,6 @@ function syncChannels(
         };
         if (ch.externalChatId !== undefined)
           reassignSet.externalChatId = ch.externalChatId;
-        if (!isBlocked) {
-          if (ch.status !== undefined) reassignSet.status = ch.status;
-          if (ch.policy !== undefined) reassignSet.policy = ch.policy;
-          if (ch.revokedReason !== undefined)
-            reassignSet.revokedReason = ch.revokedReason;
-          if (ch.blockedReason !== undefined)
-            reassignSet.blockedReason = ch.blockedReason;
-        }
-        if (ch.verifiedAt !== undefined) reassignSet.verifiedAt = ch.verifiedAt;
-        if (ch.verifiedVia !== undefined)
-          reassignSet.verifiedVia = ch.verifiedVia;
         if (ch.inviteId !== undefined) reassignSet.inviteId = ch.inviteId;
 
         db.update(contactChannels)
@@ -478,10 +416,6 @@ function syncChannels(
         address: ch.address,
         isPrimary: ch.isPrimary ?? false,
         externalChatId: ch.externalChatId ?? null,
-        status: ch.status ?? "unverified",
-        policy: ch.policy ?? "allow",
-        verifiedAt: ch.verifiedAt ?? null,
-        verifiedVia: ch.verifiedVia ?? null,
         inviteId: ch.inviteId ?? null,
         createdAt: now,
         updatedAt: now,
@@ -494,7 +428,6 @@ export function searchContacts(params: {
   query?: string;
   channelAddress?: string;
   channelType?: string;
-  role?: ContactRole;
   contactType?: ContactType;
   limit?: number;
 }): ContactWithChannels[] {
@@ -534,7 +467,6 @@ export function searchContacts(params: {
       const contact = getContactInternal(id);
       if (
         contact &&
-        (!params.role || contact.role === params.role) &&
         (!params.contactType || contact.contactType === params.contactType) &&
         (!sanitizedQuery ||
           (contact.displayName &&
@@ -564,7 +496,6 @@ export function searchContacts(params: {
       const contact = getContactInternal(id);
       if (
         contact &&
-        (!params.role || contact.role === params.role) &&
         (!params.contactType || contact.contactType === params.contactType)
       ) {
         results.push(contact);
@@ -577,14 +508,11 @@ export function searchContacts(params: {
   const conditions = [];
   if (params.query) {
     const sanitized = escapeLike(params.query);
-    if (!sanitized && !params.role && !params.contactType) return [];
+    if (!sanitized && !params.contactType) return [];
     if (sanitized) {
       conditions.push(like(contacts.displayName, `%${sanitized}%`));
     }
   }
-  if (params.role) {
-    conditions.push(eq(contacts.role, params.role));
-  }
   if (params.contactType) {
     conditions.push(eq(contacts.contactType, params.contactType));
   }
@@ -633,20 +561,16 @@ export function searchContacts(params: {
 
 export function listContacts(
   limit = 50,
-  role?: ContactRole,
   contactType?: ContactType,
   opts?: { uncapped?: boolean },
 ): ContactWithChannels[] {
   const db = getDb();
   const effectiveLimit = opts?.uncapped ? limit : Math.min(limit, 200);
-  const conditions = [];
-  if (role) conditions.push(eq(contacts.role, role));
-  if (contactType) conditions.push(eq(contacts.contactType, contactType));
   const rows = db
     .select()
     .from(contacts)
-    .where(conditions.length === 1 ? conditions[0] : and(...conditions))
-    .orderBy(sql`${contacts.role} = 'guardian' DESC`, desc(contacts.updatedAt))
+    .where(contactType ? eq(contacts.contactType, contactType) : undefined)
+    .orderBy(desc(contacts.updatedAt))
     .limit(effectiveLimit)
     .all();
   return rows.map((r) => withChannels(parseContact(r)));
@@ -758,7 +682,8 @@ export function findContactByAddress(
 /**
  * Find a contact by channel external chat ID. Fallback for callers that only
  * have a chat ID (no user-level address) — matches by (type, externalChatId).
- * No unique constraint exists on externalChatId, so ORDER BY is needed.
+ * No unique constraint exists on externalChatId, so ORDER BY is needed for a
+ * deterministic pick; channel ranking (status) is owned by the gateway now.
  */
 function findContactByChannelExternalChatId(
   channelType: string,
@@ -774,14 +699,7 @@ function findContactByChannelExternalChatId(
         eq(contactChannels.externalChatId, externalChatId),
       ),
     )
-    .orderBy(
-      sql`CASE ${contactChannels.status}
-        WHEN 'active' THEN 0
-        WHEN 'unverified' THEN 1
-        ELSE 2
-      END`,
-      desc(contactChannels.updatedAt),
-    )
+    .orderBy(desc(contactChannels.updatedAt), desc(contactChannels.createdAt))
     .get();
   if (!channel) return null;
   return getContactInternal(channel.contactId);
@@ -830,131 +748,10 @@ export function findContactChannel(params: {
 }
 
 /**
- * Find the guardian contact and their specific channel entry for a given channel type.
- * This is the contacts-based equivalent of getGuardianBinding(assistantId, channel).
- * Returns null if no guardian contact has a channel of the specified type.
- */
-export function findGuardianForChannel(
-  channelType: string,
-): { contact: Contact; channel: ContactChannel } | null {
-  const db = getDb();
-  const conditions = [
-    eq(contacts.role, "guardian"),
-    eq(contactChannels.type, channelType),
-    eq(contactChannels.status, "active"),
-  ];
-  const rows = db
-    .select({
-      contact: contacts,
-      channel: contactChannels,
-    })
-    .from(contacts)
-    .innerJoin(contactChannels, eq(contacts.id, contactChannels.contactId))
-    .where(and(...conditions))
-    .orderBy(desc(contactChannels.verifiedAt))
-    .limit(1)
-    .all();
-
-  if (rows.length === 0) return null;
-  const row = rows[0];
-  return {
-    contact: parseContact(row.contact),
-    channel: parseChannel(row.channel),
-  };
-}
-
-/**
- * List all active channels for guardian contacts.
- * This is the contacts-based equivalent of listActiveBindingsByAssistant(assistantId).
- * Joins contacts+channels with status='active' in a single query so we never
- * pick a guardian that has no active channels.
- * Returns channels ordered by most-recently-verified first.
- */
-export function listGuardianChannels(): {
-  contact: Contact;
-  channels: ContactChannel[];
-} | null {
-  const db = getDb();
-  const rows = db
-    .select({
-      contact: contacts,
-      channel: contactChannels,
-    })
-    .from(contacts)
-    .innerJoin(contactChannels, eq(contacts.id, contactChannels.contactId))
-    .where(
-      and(eq(contacts.role, "guardian"), eq(contactChannels.status, "active")),
-    )
-    .orderBy(desc(contactChannels.verifiedAt))
-    .all();
-
-  if (rows.length === 0) return null;
-
-  // Use the first row's contact (the guardian with the most-recently-verified
-  // active channel) and collect all active channels for that contact.
-  const guardian = parseContact(rows[0].contact);
-  const channels = rows
-    .filter((r) => r.contact.id === guardian.id)
-    .map((r) => parseChannel(r.channel));
-
-  return { contact: guardian, channels };
-}
-
-/**
- * Update a channel's access-control fields (status, policy, reasons).
- * Returns the updated channel, or null if the channel does not exist.
- */
-export function updateChannelStatus(
-  channelId: string,
-  params: {
-    status?: ChannelStatus;
-    policy?: ChannelPolicy;
-    revokedReason?: string | null;
-    blockedReason?: string | null;
-  },
-): ContactChannel | null {
-  const db = getDb();
-  const existing = db
-    .select()
-    .from(contactChannels)
-    .where(eq(contactChannels.id, channelId))
-    .get();
-
-  if (!existing) return null;
-
-  const updateSet: Record<string, unknown> = {};
-  if (params.status !== undefined) updateSet.status = params.status;
-  if (params.policy !== undefined) updateSet.policy = params.policy;
-  if (params.revokedReason !== undefined)
-    updateSet.revokedReason = params.revokedReason;
-  if (params.blockedReason !== undefined)
-    updateSet.blockedReason = params.blockedReason;
-
-  if (Object.keys(updateSet).length > 0) {
-    updateSet.updatedAt = Date.now();
-    db.update(contactChannels)
-      .set(updateSet)
-      .where(eq(contactChannels.id, channelId))
-      .run();
-
-    const updated = db
-      .select()
-      .from(contactChannels)
-      .where(eq(contactChannels.id, channelId))
-      .get();
-
-    const result = updated ? parseChannel(updated) : null;
-    emitContactChange();
-    return result;
-  }
-
-  return parseChannel(existing);
-}
-
-/**
- * Update a guardian contact's principalId and its channel's identity fields.
- * Used for healing guardian binding drift when the JWT principal no longer
- * matches the stored guardian binding after a DB reset.
+ * Heal a guardian channel's identity address when the JWT principal no longer
+ * matches the stored guardian binding after a DB reset. The principalId ACL
+ * column is gateway-owned and no longer written here; only the channel identity
+ * address is repaired.
  *
  * Returns false if the update would violate the unique (type, address)
  * constraint on contact_channels — e.g. when the incoming principal already
@@ -962,7 +759,7 @@ export function updateChannelStatus(
  * In that case the heal is skipped and trust stays `unknown`.
  */
 export function updateContactPrincipalAndChannel(
-  contactId: string,
+  _contactId: string,
   channelId: string,
   newPrincipalId: string,
 ): boolean {
@@ -983,20 +780,13 @@ export function updateContactPrincipalAndChannel(
     return false;
   }
 
-  db.transaction(() => {
-    db.update(contacts)
-      .set({ principalId: newPrincipalId, updatedAt: now })
-      .where(eq(contacts.id, contactId))
-      .run();
-
-    db.update(contactChannels)
-      .set({
-        address: newPrincipalId,
-        updatedAt: now,
-      })
-      .where(eq(contactChannels.id, channelId))
-      .run();
-  });
+  db.update(contactChannels)
+    .set({
+      address: newPrincipalId,
+      updatedAt: now,
+    })
+    .where(eq(contactChannels.id, channelId))
+    .run();
 
   emitContactChange();
   return true;

package/src/contacts/contacts-write.ts

@@ -6,47 +6,33 @@
  * identity and access-control state.
  */
 
-import { emitContactChange } from "./contact-events.js";
 import {
   findContactChannel,
-  findGuardianForChannel,
   getChannelById,
   getContact,
   getContactInternal,
-  updateChannelStatus,
   upsertContact,
 } from "./contact-store.js";
-import type {
-  ChannelPolicy,
-  ChannelStatus,
-  ContactRole,
-  ContactWriteResult,
-} from "./types.js";
+import type { ContactWriteResult } from "./types.js";
 
 // ── Guardian operations ──────────────────────────────────────────────
 
 /**
- * Revoke a guardian binding by updating the contacts table.
- * Returns true when a guardian channel was found and revoked, false otherwise.
+ * No-op shim: the guardian channel ACL revoke is gateway-owned (relayed via
+ * mark_channel_revoked). Retained while callers still invoke it; the return is
+ * discarded.
  */
-export function revokeGuardianBinding(channel: string): boolean {
-  const guardian = findGuardianForChannel(channel);
-  if (!guardian) return false;
-
-  updateChannelStatus(guardian.channel.id, {
-    status: "revoked",
-    revokedReason: "binding_revoked",
-  });
-  emitContactChange();
-  return true;
+export function revokeGuardianBinding(_channel: string): boolean {
+  return false;
 }
 
 // ── Member operations ────────────────────────────────────────────────
 
 /**
- * Upsert a contact and channel by writing to the contacts table.
- * Returns the native Contact + ContactChannel, or null if no usable
- * identity was provided or the lookup failed after upsert.
+ * Upsert a contact and channel identity by writing to the contacts table.
+ * Persists only identity/INFO — the gateway owns the ACL verdict. Returns the
+ * native Contact + ContactChannel, or null if no usable identity was provided
+ * or the lookup failed after upsert.
  */
 export function upsertContactChannel(params: {
   sourceChannel: string;
@@ -54,12 +40,7 @@ export function upsertContactChannel(params: {
   externalChatId?: string;
   displayName?: string;
   username?: string;
-  policy?: string;
-  status?: string;
   inviteId?: string;
-  verifiedAt?: number;
-  verifiedVia?: string;
-  role?: ContactRole;
   contactId?: string;
 }): ContactWriteResult | null {
   let address: string;
@@ -88,19 +69,12 @@ export function upsertContactChannel(params: {
   upsertContact({
     id: params.contactId,
     displayName,
-    role: params.role,
     channels: [
       {
         type: params.sourceChannel,
         address,
         externalChatId: params.externalChatId ?? null,
-        status: (params.status as ChannelStatus) ?? undefined,
-        policy: (params.policy as ChannelPolicy) ?? undefined,
         inviteId: params.inviteId ?? null,
-        revokedReason: params.status === "active" ? null : undefined,
-        blockedReason: params.status === "active" ? null : undefined,
-        verifiedAt: params.verifiedAt ?? undefined,
-        verifiedVia: params.verifiedVia ?? undefined,
       },
     ],
     // When a specific contactId is provided, reassign conflicting channels from
@@ -129,32 +103,21 @@ export function upsertContactChannel(params: {
 }
 
 /**
- * Revoke a contact channel by updating its status.
- * The memberId may be a plain channel ID (internal callers) or a composite
- * contactId:channelId (from the API response format).
+ * Resolve the native contact/channel for a member id. The ACL downgrade is
+ * gateway-owned (relayed via mark_channel_revoked); this no longer mutates
+ * local status. The memberId may be a plain channel ID (internal callers) or a
+ * composite contactId:channelId (from the API response format).
  */
-export function revokeMember(
-  memberId: string,
-  reason?: string,
-): ContactWriteResult | null {
+export function revokeMember(memberId: string): ContactWriteResult | null {
   const channelId = memberId.includes(":") ? memberId.split(":")[1] : memberId;
 
   const channelRow = getChannelById(channelId);
   if (!channelRow) return null;
-  if (channelRow.status !== "active" && channelRow.status !== "pending")
-    return null;
-
-  updateChannelStatus(channelId, {
-    status: "revoked",
-    revokedReason: reason ?? null,
-  });
 
-  // Use unscoped lookup — the contact was already resolved via channel ID
   const contact = getContactInternal(channelRow.contactId);
   if (!contact) return null;
-  const updatedChannel = contact.channels.find((ch) => ch.id === channelId);
-  if (!updatedChannel) return null;
+  const channel = contact.channels.find((ch) => ch.id === channelId);
+  if (!channel) return null;
 
-  emitContactChange();
-  return { contact, channel: updatedChannel };
+  return { contact, channel };
 }

package/src/contacts/gateway-channel-read.ts

@@ -0,0 +1,51 @@
+import { GetContactIpcResponseSchema } from "@vellumai/gateway-client/gateway-ipc-contracts";
+
+import { ipcCallPersistent } from "../ipc/gateway-client.js";
+import { getLogger } from "../util/logger.js";
+import type { ContactChannel } from "./types.js";
+
+const log = getLogger("gateway-channel-read");
+
+/**
+ * Read a contact channel's verified state from the gateway contact-channel read
+ * (ACL source of truth). Covers all contacts, not just guardian deliveries.
+ *
+ * Matches the gateway row by logical identity — `(type, address)`,
+ * case-insensitive — not by id, so a reconcile-divergent row that the gateway
+ * write helpers re-keyed under a different UUID is still found.
+ *
+ * Returns `undefined` for unreachable reads (gateway down, IPC timeout, schema
+ * mismatch) or when no such channel exists, so callers fail open.
+ */
+export async function gatewayContactChannelState(
+  channel: Pick<ContactChannel, "contactId" | "type" | "address">,
+): Promise<{ status: string; verifiedAt: number | null } | undefined> {
+  let result: unknown;
+  try {
+    result = await ipcCallPersistent("contacts_get_rich", {
+      contactId: channel.contactId,
+    });
+  } catch (err) {
+    log.warn(
+      { err, contactId: channel.contactId },
+      "contacts_get_rich unreachable — failing open",
+    );
+    return undefined;
+  }
+  if (!result || (result as { contact?: unknown }).contact == null) {
+    return undefined;
+  }
+  const parsed = GetContactIpcResponseSchema.safeParse(result);
+  if (!parsed.success) {
+    log.warn(
+      { err: parsed.error, contactId: channel.contactId },
+      "contacts_get_rich response failed schema parse — failing open",
+    );
+    return undefined;
+  }
+  const address = channel.address.toLowerCase();
+  const ch = parsed.data.contact.channels.find(
+    (c) => c.type === channel.type && c.address.toLowerCase() === address,
+  );
+  return ch ? { status: ch.status, verifiedAt: ch.verifiedAt } : undefined;
+}