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

package/src/runtime/services/conversation-serializer.ts

@@ -8,8 +8,6 @@
  */
 
 import { parseChannelId } from "../../channels/types.js";
-import { getConfig } from "../../config/loader.js";
-import { findConversation } from "../../daemon/conversation-registry.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
   type AttentionState,
@@ -21,13 +19,11 @@ import {
   type ConversationRow,
   getConversation,
   getDisplayMetaForConversations,
+  isConversationProcessing,
 } from "../../memory/conversation-crud.js";
 import type { ExternalConversationBinding } from "../../memory/external-conversation-store.js";
 import { getBindingsForConversations } from "../../memory/external-conversation-store.js";
-import {
-  buildSlackMessageDeepLinks,
-  buildSlackWebChannelUrl,
-} from "../../messaging/providers/slack/deep-link.js";
+import { buildChannelBindingMetadata } from "../../messaging/channel-binding-metadata.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -126,48 +122,7 @@ function resolveSerializedGroupId(
 }
 
 function buildChannelBinding(binding: ExternalConversationBinding) {
-  const externalChatName =
-    binding.externalChatName?.trim() ||
-    (binding.sourceChannel === "slack" ? binding.externalChatId : undefined);
-  const slackConfig =
-    binding.sourceChannel === "slack" ? getConfig().slack : undefined;
-  const slackThreadLink =
-    slackConfig && binding.externalThreadId
-      ? buildSlackMessageDeepLinks({
-          teamId: slackConfig.teamId,
-          teamUrl: slackConfig.teamUrl,
-          channelId: binding.externalChatId,
-          messageTs: binding.externalThreadId,
-        })
-      : undefined;
-  const slackThread =
-    binding.sourceChannel === "slack" && binding.externalThreadId
-      ? {
-          channelId: binding.externalChatId,
-          threadTs: binding.externalThreadId,
-          ...(slackThreadLink ? { link: slackThreadLink } : {}),
-        }
-      : undefined;
-  const slackChannelWebUrl = slackConfig
-    ? buildSlackWebChannelUrl({
-        teamUrl: slackConfig.teamUrl,
-        channelId: binding.externalChatId,
-      })
-    : undefined;
-  const slackChannel =
-    binding.sourceChannel === "slack"
-      ? {
-          channelId: binding.externalChatId,
-          name: externalChatName,
-          ...(slackChannelWebUrl
-            ? {
-                link: {
-                  webUrl: slackChannelWebUrl,
-                },
-              }
-            : {}),
-        }
-      : undefined;
+  const externalChatName = binding.externalChatName?.trim() || undefined;
 
   return {
     sourceChannel: binding.sourceChannel,
@@ -179,8 +134,10 @@ function buildChannelBinding(binding: ExternalConversationBinding) {
     externalUserId: binding.externalUserId,
     displayName: binding.displayName,
     username: binding.username,
-    ...(slackThread ? { slackThread } : {}),
-    ...(slackChannel ? { slackChannel } : {}),
+    // Channel-specific enrichment (e.g. Slack deep links) is contributed by
+    // the source channel's binding-metadata builder, keeping this serializer
+    // channel-agnostic.
+    ...buildChannelBindingMetadata(binding),
   };
 }
 
@@ -196,9 +153,9 @@ export function serializeConversationSummary(params: {
   parentCache: Map<string, ConversationRow | null>;
   /**
    * Whether the agent loop is currently mid-turn for this conversation.
-   * Sourced from the in-memory daemon `Conversation.isProcessing()` flag
-   * — callers resolve via `findConversation(id)?.isProcessing() ?? false`
-   * so cold (evicted / never-loaded) rows report `false`. Plumbed in
+   * Resolved by `isConversationProcessing(id)`, which checks the in-memory
+   * daemon flag first and falls back to the persisted
+   * `processing_started_at` column for cold conversations. Plumbed in
    * rather than read here so the serializer stays a pure shape mapper
    * with no daemon-store coupling.
    */
@@ -286,11 +243,9 @@ export function buildConversationDetailResponse(
       attentionState: attentionStates.get(conversation.id),
       displayMeta: displayMeta.get(conversation.id),
       parentCache,
-      // Cold (evicted / never-loaded) rows aren't in the in-memory
-      // store, so `findConversation` returns `undefined` and they
-      // report `isProcessing: false` — by definition they aren't
-      // mid-turn since the agent loop only runs on resident convs.
-      isProcessing: findConversation(conversation.id)?.isProcessing() ?? false,
+      // Checks in-memory flag first (hot path), falls back to the
+      // persisted `processing_started_at` column for cold conversations.
+      isProcessing: isConversationProcessing(conversation.id),
     }),
   };
 }

package/src/runtime/tool-grant-request-helper.ts

@@ -59,9 +59,9 @@ export type ToolGrantRequestResult =
  * Returns a result indicating whether a new request was created, an existing
  * one was deduped, or the escalation failed (no binding, missing identity).
  */
-export function createOrReuseToolGrantRequest(
+export async function createOrReuseToolGrantRequest(
   params: ToolGrantRequestParams,
-): ToolGrantRequestResult {
+): Promise<ToolGrantRequestResult> {
   const {
     assistantId,
     sourceChannel,
@@ -78,7 +78,7 @@ export function createOrReuseToolGrantRequest(
     return { failed: true, reason: "missing_identity" };
   }
 
-  const binding = getGuardianBinding(assistantId, sourceChannel);
+  const binding = await getGuardianBinding(assistantId, sourceChannel);
   if (!binding) {
     log.debug(
       { sourceChannel, assistantId },

package/src/runtime/trust-verdict-consumer.ts

@@ -4,10 +4,9 @@
  *
  * The gateway resolves a per-actor verdict from its ACL DB and stamps it onto
  * inbound `sourceMetadata`. These pure mappers turn that verdict into the same
- * {@link TrustContext} / {@link ResolvedMember} the local resolver would have
- * produced — ACL + identity only. INFO fields (notes, userFile, contactType,
- * interactionCount) are never carried on the wire; the consumer re-joins them
- * locally by contactId.
+ * {@link TrustContext} the local resolver would have produced — ACL + identity
+ * only. INFO fields (notes, userFile, contactType, interactionCount) are never
+ * carried on the wire; the consumer re-joins them locally by contactId.
  */
 
 import type { TrustVerdict } from "@vellumai/gateway-client";
@@ -18,12 +17,12 @@ import type {
   ChannelPolicy,
   ChannelStatus,
   ContactChannel,
+  ContactRole,
   ContactWithChannels,
 } from "../contacts/types.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import type { ActorTrustContext } from "./actor-trust-resolver.js";
 import { toTrustContext } from "./actor-trust-resolver.js";
-import type { ResolvedMember } from "./routes/inbound-stages/acl-enforcement.js";
 
 export interface TrustVerdictTransport {
   sourceChannel: ChannelId;
@@ -33,16 +32,17 @@ export interface TrustVerdictTransport {
 }
 
 /**
- * Build a {@link TrustContext} from a gateway verdict + transport identity.
+ * Reassemble an {@link ActorTrustContext} from a gateway verdict + transport
+ * identity (mirroring `resolveActorTrust`), without any local DB/IPC reads.
  *
- * Reassembles an {@link ActorTrustContext} (mirroring `resolveActorTrust`) and
- * routes it through {@link toTrustContext}, so the output is byte-identical to
- * the local resolution path.
+ * Pure: the voice path consumes this directly for routing on
+ * `actorTrust.trustClass`; {@link trustContextFromVerdict} routes it through
+ * {@link toTrustContext}.
  */
-export function trustContextFromVerdict(
+export function actorTrustContextFromVerdict(
   verdict: TrustVerdict,
   input: TrustVerdictTransport,
-): TrustContext {
+): ActorTrustContext {
   const canonicalSenderId = verdict.canonicalSenderId;
   const memberDisplayName = verdict.memberDisplayName;
   const senderDisplayName = input.actorDisplayName;
@@ -51,7 +51,7 @@ export function trustContextFromVerdict(
     ? `@${username}`
     : (canonicalSenderId ?? undefined);
 
-  const actorTrustContext: ActorTrustContext = {
+  return {
     canonicalSenderId,
     guardianBindingMatch: verdict.guardianExternalUserId
       ? {
@@ -60,7 +60,12 @@ export function trustContextFromVerdict(
         }
       : null,
     guardianPrincipalId: verdict.guardianPrincipalId,
-    memberRecord: null,
+    // Populate from the verdict so the voice path's ACL gates (which read
+    // actorTrust.memberRecord.channel status/policy) enforce blocked/revoked/
+    // deny/escalate. Null for memberless verdicts. Text path is unaffected:
+    // toTrustContext derives the same member fields trustContextFromVerdict
+    // already stamps.
+    memberRecord: memberRecordFromVerdict(verdict),
     trustClass: verdict.trustClass,
     actorMetadata: {
       identifier,
@@ -72,25 +77,57 @@ export function trustContextFromVerdict(
       trustStatus: verdict.trustClass,
     },
   };
+}
 
+/**
+ * Build a {@link TrustContext} from a gateway verdict + transport identity.
+ *
+ * Reassembles an {@link ActorTrustContext} (mirroring `resolveActorTrust`) and
+ * routes it through {@link toTrustContext}, so the output is byte-identical to
+ * the local resolution path.
+ */
+export function trustContextFromVerdict(
+  verdict: TrustVerdict,
+  input: TrustVerdictTransport,
+): TrustContext {
   const context = toTrustContext(
-    actorTrustContext,
+    actorTrustContextFromVerdict(verdict, input),
     input.conversationExternalId,
   );
 
   // Stamp the verdict's ACL member fields onto the context so downstream turn
   // assembly reads member status/policy from the verdict rather than a local
   // re-resolution. The contact ID anchors the local info-only join.
-  const member = resolvedMemberFromVerdict(verdict);
+  const member = verdictMemberFromVerdict(verdict);
   if (member) {
-    context.requesterContactId = member.contact.id;
-    context.memberStatus = channelStatusToMemberStatus(member.channel.status);
-    context.memberPolicy = member.channel.policy;
+    context.requesterContactId = member.contactId;
+    context.memberStatus = channelStatusToMemberStatus(member.status);
+    context.memberPolicy = member.policy;
   }
 
   return context;
 }
 
+/**
+ * True when the verdict carries a member identity (contactId or channelId),
+ * regardless of whether that member resolves to a usable {@link VerdictMember}.
+ */
+export function verdictHasMemberIdentity(verdict: TrustVerdict): boolean {
+  return !!(verdict.contactId || verdict.channelId);
+}
+
+/**
+ * True when the verdict claims a member identity but that member can't be
+ * resolved (partial/mixed-version verdict). Such a verdict is unusable —
+ * callers fall back to local resolution.
+ */
+export function verdictMemberUnresolvable(verdict: TrustVerdict): boolean {
+  return (
+    verdictHasMemberIdentity(verdict) &&
+    verdictMemberFromVerdict(verdict) === null
+  );
+}
+
 // Allowed ACL enum values, kept in sync with the ContactChannel union types.
 const CHANNEL_STATUS_VALUES: readonly ChannelStatus[] = [
   "active",
@@ -114,38 +151,64 @@ function isChannelPolicy(value: string): value is ChannelPolicy {
 }
 
 /**
- * Build a synthetic {@link ResolvedMember} from a gateway verdict.
+ * The ACL fields a gateway verdict carries for a resolved member, decoupled
+ * from the schema-derived {@link ContactChannel}.
+ */
+export interface VerdictMember {
+  contactId: string;
+  channelId: string;
+  status: ChannelStatus;
+  policy: ChannelPolicy;
+  verifiedAt: number | null;
+  displayName: string | null;
+}
+
+/**
+ * Extract the narrow {@link VerdictMember} ACL view from a gateway verdict.
  *
- * ACL + identity only; info fields are placeholders, re-joined locally by
- * contactId. Returns null for memberless verdicts.
+ * Guards on contactId/channelId presence + known status/policy enums, failing
+ * closed to null otherwise.
  */
-export function resolvedMemberFromVerdict(
+export function verdictMemberFromVerdict(
   verdict: TrustVerdict,
-): ResolvedMember | null {
+): VerdictMember | null {
   if (!verdict.contactId || !verdict.channelId) return null;
-  // Member verdict requires valid known status+policy enums, else null
-  // (fail-closed): a partial/mixed-version verdict (absent OR
-  // present-but-unknown ACL value) must not synthesize an active/allow channel
-  // that would skip ingress ACL gates.
   if (!verdict.status || !verdict.policy) return null;
   if (!isChannelStatus(verdict.status) || !isChannelPolicy(verdict.policy)) {
     return null;
   }
 
-  const channel: ContactChannel = {
-    id: verdict.channelId,
+  return {
     contactId: verdict.contactId,
+    channelId: verdict.channelId,
+    status: verdict.status,
+    policy: verdict.policy,
+    verifiedAt: verdict.verifiedAt ?? null,
+    displayName: verdict.memberDisplayName ?? null,
+  };
+}
+
+/**
+ * Build the voice-path {@link ActorTrustContext.memberRecord} from a gateway
+ * verdict's narrow ACL view.
+ *
+ * ACL + identity only; info fields are placeholders, re-joined locally by
+ * contactId. Returns null for memberless/unresolvable verdicts.
+ */
+function memberRecordFromVerdict(
+  verdict: TrustVerdict,
+): ActorTrustContext["memberRecord"] {
+  const member = verdictMemberFromVerdict(verdict);
+  if (!member) return null;
+
+  const channel: ContactChannel = {
+    id: member.channelId,
+    contactId: member.contactId,
     type: verdict.type ?? "",
     address: verdict.address ?? "",
     isPrimary: false,
     externalChatId: verdict.externalChatId ?? null,
-    status: verdict.status,
-    policy: verdict.policy,
-    verifiedAt: verdict.verifiedAt ?? null,
-    verifiedVia: verdict.verifiedVia ?? null,
     inviteId: null,
-    revokedReason: null,
-    blockedReason: null,
     lastSeenAt: null,
     interactionCount: 0,
     lastInteraction: null,
@@ -153,20 +216,28 @@ export function resolvedMemberFromVerdict(
     createdAt: 0,
   };
 
+  const role: ContactRole =
+    verdict.trustClass === "guardian" ? "guardian" : "contact";
+
   const contact: ContactWithChannels = {
-    id: verdict.contactId,
-    displayName: verdict.memberDisplayName ?? "",
+    id: member.contactId,
+    displayName: member.displayName ?? "",
     notes: null,
+    role,
     lastInteraction: null,
     interactionCount: 0,
     createdAt: 0,
     updatedAt: 0,
-    role: verdict.trustClass === "guardian" ? "guardian" : "contact",
     contactType: "human",
-    principalId: verdict.guardianPrincipalId ?? null,
     userFile: null,
     channels: [channel],
   };
 
-  return { contact, channel };
+  return {
+    contact,
+    channel,
+    status: member.status,
+    policy: member.policy,
+    role,
+  };
 }

package/src/runtime/verification-outbound-actions.ts

@@ -21,7 +21,7 @@ import {
   countRecentSendsToDestination,
   createOutboundSession,
   findActiveSession,
-  getGuardianBinding,
+  isGuardianBoundForChannel,
   updateSessionDelivery,
   updateSessionStatus,
 } from "./channel-verification-service.js";
@@ -224,7 +224,7 @@ export async function startOutbound(
       originConversationId,
     );
   } else if (channel === "phone") {
-    return startOutboundVoice(
+    return await startOutboundVoice(
       params.destination,
       assistantId,
       channel,
@@ -232,7 +232,7 @@ export async function startOutbound(
       originConversationId,
     );
   } else if (channel === "slack") {
-    return startOutboundSlack(
+    return await startOutboundSlack(
       params.destination,
       assistantId,
       channel,
@@ -240,7 +240,7 @@ export async function startOutbound(
       originConversationId,
     );
   } else if (channel === "email") {
-    return startOutboundEmail(
+    return await startOutboundEmail(
       params.destination,
       assistantId,
       channel,
@@ -274,8 +274,8 @@ async function startOutboundTelegram(
     };
   }
 
-  const existingBinding = getGuardianBinding(assistantId, channel);
-  if (existingBinding && !rebind) {
+  const alreadyBound = await isGuardianBoundForChannel(channel);
+  if (alreadyBound && !rebind) {
     return {
       success: false,
       error: "already_bound",
@@ -394,13 +394,13 @@ async function startOutboundTelegram(
   };
 }
 
-function startOutboundVoice(
+async function startOutboundVoice(
   rawDestination: string | undefined,
   assistantId: string,
   channel: ChannelId,
   rebind?: boolean,
   originConversationId?: string,
-): OutboundActionResult {
+): Promise<OutboundActionResult> {
   if (!rawDestination) {
     return {
       success: false,
@@ -422,8 +422,8 @@ function startOutboundVoice(
     };
   }
 
-  const existingBinding = getGuardianBinding(assistantId, channel);
-  if (existingBinding && !rebind) {
+  const alreadyBound = await isGuardianBoundForChannel(channel);
+  if (alreadyBound && !rebind) {
     return {
       success: false,
       error: "already_bound",
@@ -591,13 +591,13 @@ export function deliverVerificationEmail(
   })();
 }
 
-function startOutboundSlack(
+async function startOutboundSlack(
   destination: string | undefined,
   assistantId: string,
   channel: ChannelId,
   rebind?: boolean,
   originConversationId?: string,
-): OutboundActionResult {
+): Promise<OutboundActionResult> {
   if (!destination) {
     return {
       success: false,
@@ -607,8 +607,8 @@ function startOutboundSlack(
     };
   }
 
-  const existingBinding = getGuardianBinding(assistantId, channel);
-  if (existingBinding && !rebind) {
+  const alreadyBound = await isGuardianBoundForChannel(channel);
+  if (alreadyBound && !rebind) {
     return {
       success: false,
       error: "already_bound",
@@ -669,13 +669,13 @@ function startOutboundSlack(
   };
 }
 
-function startOutboundEmail(
+async function startOutboundEmail(
   destination: string | undefined,
   assistantId: string,
   channel: ChannelId,
   rebind?: boolean,
   originConversationId?: string,
-): OutboundActionResult {
+): Promise<OutboundActionResult> {
   if (!destination) {
     return {
       success: false,
@@ -688,8 +688,8 @@ function startOutboundEmail(
 
   const normalizedEmail = destination.trim().toLowerCase();
 
-  const existingBinding = getGuardianBinding(assistantId, channel);
-  if (existingBinding && !rebind) {
+  const alreadyBound = await isGuardianBoundForChannel(channel);
+  if (alreadyBound && !rebind) {
     return {
       success: false,
       error: "already_bound",

package/src/signals/user-message.ts

@@ -15,6 +15,7 @@ import { readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
+import { supersedePendingInteractionsOnEnqueue } from "../daemon/handlers/conversations.js";
 import type { UserMessageAttachment } from "../daemon/message-types/shared.js";
 import {
   processMessageInBackground,
@@ -131,6 +132,21 @@ async function dispatchUserMessage(params: {
         assistantMessageInterface: resolvedInterface,
       },
     });
+    if (!result.rejected) {
+      // Mirror the HTTP send path: a follow-up enqueued while the turn is busy
+      // auto-denies pending confirmations and supersedes a parked ask_question
+      // so it isn't stranded behind the prompt until the response backstop.
+      // Best-effort — the message is already queued, so a cleanup failure must
+      // not surface as an error that makes the CLI retry and enqueue a duplicate.
+      try {
+        supersedePendingInteractionsOnEnqueue(conversationId, requestId);
+      } catch (err) {
+        log.warn(
+          { err, conversationId },
+          "Post-enqueue supersession failed — queued message unaffected",
+        );
+      }
+    }
     return { accepted: !result.rejected };
   }
 

package/src/subagent/__tests__/consult-prompt.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test";
+
+import { advisorRequestText, buildAdvisorSystem } from "../consult-prompt.js";
+
+describe("buildAdvisorSystem", () => {
+  test("includes the senior-advisor framing", () => {
+    const prompt = buildAdvisorSystem(null);
+    expect(prompt).toContain("senior advisor");
+  });
+
+  test("embeds the parent prompt inside <agent_system_prompt> when provided", () => {
+    const prompt = buildAdvisorSystem("You are a coding agent.");
+    expect(prompt).toContain(
+      "<agent_system_prompt>\nYou are a coding agent.\n</agent_system_prompt>",
+    );
+  });
+
+  test("omits the <agent_system_prompt> block when no parent prompt is given", () => {
+    const prompt = buildAdvisorSystem(null);
+    expect(prompt).not.toContain("<agent_system_prompt>");
+  });
+});
+
+describe("advisorRequestText", () => {
+  test("is non-empty and asks for focused strategic guidance", () => {
+    const text = advisorRequestText();
+    expect(text.length).toBeGreaterThan(0);
+    expect(text).toContain("focused strategic guidance");
+  });
+
+  test("imposes no length cap", () => {
+    // The request must not constrain how much the advisor writes.
+    expect(advisorRequestText()).not.toContain("words");
+  });
+});