@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/runtime/routes/conversation-starter-routes.ts

@@ -21,7 +21,7 @@ import {
   buildConversationStarterValidationContext,
   isValidConversationStarterText,
 } from "../../memory/conversation-starter-validation.js";
-import { getDb } from "../../memory/db-connection.js";
+import { getDb, getMemoryDb } from "../../memory/db-connection.js";
 import { enqueueMemoryJob, isMemoryEnabled } from "../../memory/jobs-store.js";
 import { conversationStarters, memoryJobs } from "../../memory/schema.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
@@ -49,12 +49,11 @@ export const CONVERSATION_STARTERS_STALE_TTL_MS = 4 * 60 * 60 * 1000;
  *  when generation repeatedly fails or produces 0 valid starters). */
 const REFRESH_COOLDOWN_MS = 5 * 60 * 1000;
 
-function hasActiveConversationStarterJob(
-  db: ReturnType<typeof getDb>,
-  scopeId: string,
-): boolean {
+function hasActiveConversationStarterJob(scopeId: string): boolean {
+  const memoryDb = getMemoryDb();
+  if (!memoryDb) return false;
   return (
-    db
+    memoryDb
       .select({ id: memoryJobs.id })
       .from(memoryJobs)
       .where(
@@ -200,7 +199,7 @@ function handleListConversationStarters({
       lastGenAt == null ||
       Date.now() - lastGenAt >= CONVERSATION_STARTERS_STALE_TTL_MS;
     const checkpointAhead = lastCount != null && totalActive < lastCount;
-    let hasActiveJob = hasActiveConversationStarterJob(db, scopeId);
+    let hasActiveJob = hasActiveConversationStarterJob(scopeId);
     const lastAttemptAt = parseCheckpointInt(
       getCheckpointValue(checkpointKey(CK_LAST_ATTEMPT_AT, scopeId)),
     );
@@ -232,7 +231,7 @@ function handleListConversationStarters({
     return { starters: [], total: 0, status: "empty" };
   }
 
-  const existing = hasActiveConversationStarterJob(db, scopeId);
+  const existing = hasActiveConversationStarterJob(scopeId);
 
   if (!existing && isMemoryEnabled()) {
     enqueueMemoryJob("generate_conversation_starters", { scopeId });

package/src/runtime/routes/guardian-approval-interception.ts

@@ -2,21 +2,14 @@
  * Approval interception: checks for pending approvals and handles inbound
  * messages as decisions, reminders, or conversational follow-ups.
  *
- * This module is the top-level dispatcher. It delegates to strategy modules:
- * - guardian-callback-strategy.ts   — guardian callback button and text decisions
- * - guardian-text-engine-strategy.ts — conversational engine for plain-text messages
+ * This module is the top-level dispatcher. It delegates plain-text messages to
+ * the conversational engine in guardian-text-engine-strategy.ts.
  */
-import { applyGuardianDecision } from "../../approvals/guardian-decision-primitive.js";
+import type { KnownBlock } from "@slack/types";
+
 import type { ChannelId } from "../../channels/types.js";
 import type { TrustContext } from "../../daemon/trust-context.js";
-import {
-  getPendingApprovalForRequest,
-  getUnresolvedApprovalForRequest,
-  updateApprovalDecision,
-} from "../../memory/guardian-approvals.js";
 import { getLogger } from "../../util/logger.js";
-import { runApprovalConversationTurn } from "../approval-conversation-turn.js";
-import { composeApprovalMessageGenerative } from "../approval-message-composer.js";
 import { resolveCapabilities } from "../capabilities.js";
 import type { ApprovalDecisionResult } from "../channel-approval-types.js";
 import {
@@ -26,12 +19,10 @@ import {
 } from "../channel-approvals.js";
 import { deliverChannelReply } from "../gateway-client.js";
 import type {
-  ApprovalConversationContext,
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
 } from "../http-types.js";
 import { parseApprovalIntent } from "../nl-approval-parser.js";
-import { handleGuardianCallbackDecision } from "./approval-strategies/guardian-callback-strategy.js";
 import { handleGuardianTextEngineDecision } from "./approval-strategies/guardian-text-engine-strategy.js";
 import {
   buildGuardianDenyContext,
@@ -100,31 +91,6 @@ export async function handleApprovalInterception(
     approvalMessageTs,
   } = params;
 
-  // ── Guardian approval decision path ──
-  // When the sender is the guardian and there's a pending guardian approval
-  // request targeting this chat, the message might be a decision on behalf
-  // of a non-guardian requester. Delegated to the guardian callback strategy.
-  if (
-    resolveCapabilities(trustCtx.trustClass).canSelfApproveTools &&
-    actorExternalId
-  ) {
-    const guardianResult = await handleGuardianCallbackDecision({
-      content,
-      callbackData,
-      conversationExternalId,
-      sourceChannel,
-      actorExternalId,
-      replyCallbackUrl,
-      assistantId,
-      approvalCopyGenerator,
-      approvalConversationGenerator,
-      approvalMessageTs,
-    });
-    if (guardianResult) {
-      return guardianResult;
-    }
-  }
-
   // Slack emoji reactions are handled by the canonical guardian decision
   // pipeline (`routeGuardianReply`), invoked from the inbound reaction stage:
   // it resolves the target request from the reacted card's delivery record.
@@ -171,240 +137,13 @@ export async function handleApprovalInterception(
   if (isIdentityKnownNonGuardian) {
     const pending = getApprovalInfoByConversation(conversationId);
     if (pending.length > 0) {
-      const guardianApprovalForRequest = getPendingApprovalForRequest(
-        pending[0].requestId,
-      );
-      if (guardianApprovalForRequest) {
-        // Allow the requester to cancel their own pending guardian request.
-        // Only reject/cancel is permitted — self-approval is still blocked.
-        if (content) {
-          let requesterCancelIntent = false;
-          let cancelReplyText: string | undefined;
-          let requesterFollowupReplyText: string | undefined;
-
-          // Interpret requester follow-ups through the conversation engine so
-          // "nevermind/cancel" resolves naturally while clarifying questions
-          // remain conversational turns.
-          if (approvalConversationGenerator) {
-            const cancelContext: ApprovalConversationContext = {
-              toolName: pending[0].toolName,
-              allowedActions: ["reject"],
-              role: "requester",
-              pendingApprovals: pending.map((p) => ({
-                requestId: p.requestId,
-                toolName: p.toolName,
-              })),
-              userMessage: content,
-            };
-            const cancelResult = await runApprovalConversationTurn(
-              cancelContext,
-              approvalConversationGenerator,
-            );
-            if (cancelResult.disposition === "reject") {
-              requesterCancelIntent = true;
-              cancelReplyText = cancelResult.replyText;
-            } else if (cancelResult.disposition === "keep_pending") {
-              requesterFollowupReplyText = cancelResult.replyText;
-            }
-          }
-
-          if (requesterCancelIntent) {
-            const rejectDecision: ApprovalDecisionResult = {
-              action: "reject",
-              source: "plain_text",
-            };
-            // Apply the cancel decision through the unified primitive.
-            // The primitive handles record update and (no-op) grant logic.
-            const cancelApplyResult = await applyGuardianDecision({
-              approval: guardianApprovalForRequest,
-              decision: rejectDecision,
-              actorPrincipalId: undefined, // Interception path — principal not available
-              actorExternalUserId: actorExternalId, // Channel-native ID
-              actorChannel: sourceChannel,
-            });
-            if (cancelApplyResult.applied) {
-              // Notify requester
-              const replyText =
-                cancelReplyText ??
-                (await composeApprovalMessageGenerative(
-                  {
-                    scenario: "requester_cancel",
-                    toolName: pending[0].toolName,
-                    channel: sourceChannel,
-                  },
-                  {},
-                  approvalCopyGenerator,
-                ));
-              try {
-                const cancelPayload: Parameters<typeof deliverChannelReply>[1] =
-                  {
-                    chatId: conversationExternalId,
-                    text: replyText,
-                    assistantId,
-                  };
-                const requesterEphemeral = slackEphemeralUserId(
-                  sourceChannel,
-                  actorExternalId,
-                );
-                if (requesterEphemeral) {
-                  cancelPayload.ephemeral = true;
-                  cancelPayload.user = requesterEphemeral;
-                }
-                await deliverChannelReply(replyCallbackUrl, cancelPayload);
-              } catch (err) {
-                log.error(
-                  { err, conversationId },
-                  "Failed to deliver requester cancel notice",
-                );
-              }
-
-              // Notify guardian that the request was cancelled
-              try {
-                const guardianNotice = await composeApprovalMessageGenerative(
-                  {
-                    scenario: "guardian_decision_outcome",
-                    decision: "denied",
-                    toolName: pending[0].toolName,
-                    channel: sourceChannel,
-                  },
-                  {},
-                  approvalCopyGenerator,
-                );
-                const guardianCancelPayload: Parameters<
-                  typeof deliverChannelReply
-                >[1] = {
-                  chatId: guardianApprovalForRequest.guardianChatId,
-                  text: guardianNotice,
-                  assistantId,
-                };
-                const guardianEphemeral = slackEphemeralUserId(
-                  sourceChannel,
-                  guardianApprovalForRequest.guardianExternalUserId,
-                );
-                if (guardianEphemeral) {
-                  guardianCancelPayload.ephemeral = true;
-                  guardianCancelPayload.user = guardianEphemeral;
-                }
-                await deliverChannelReply(
-                  replyCallbackUrl,
-                  guardianCancelPayload,
-                );
-              } catch (err) {
-                log.error(
-                  { err, conversationId },
-                  "Failed to notify guardian of requester cancellation",
-                );
-              }
-
-              return { handled: true, type: "decision_applied" };
-            }
-
-            // Race condition: approval was already resolved elsewhere.
-            await deliverStaleApprovalReply({
-              scenario: "approval_already_resolved",
-              sourceChannel,
-              replyCallbackUrl,
-              chatId: conversationExternalId,
-              assistantId,
-              approvalCopyGenerator,
-              logger: log,
-              errorLogMessage:
-                "Failed to deliver stale requester-cancel notice",
-              errorLogContext: { conversationId },
-              ephemeralUserId: slackEphemeralUserId(
-                sourceChannel,
-                actorExternalId,
-              ),
-            });
-            return { handled: true, type: "stale_ignored" };
-          }
-
-          if (requesterFollowupReplyText) {
-            try {
-              const followupPayload: Parameters<typeof deliverChannelReply>[1] =
-                {
-                  chatId: conversationExternalId,
-                  text: requesterFollowupReplyText,
-                  assistantId,
-                };
-              const followupEphemeral = slackEphemeralUserId(
-                sourceChannel,
-                actorExternalId,
-              );
-              if (followupEphemeral) {
-                followupPayload.ephemeral = true;
-                followupPayload.user = followupEphemeral;
-              }
-              await deliverChannelReply(replyCallbackUrl, followupPayload);
-            } catch (err) {
-              log.error(
-                { err, conversationId },
-                "Failed to deliver requester follow-up reply while awaiting guardian",
-              );
-            }
-            return { handled: true, type: "assistant_turn" };
-          }
-        }
-
-        // Not a cancel intent — tell the requester their request is pending
-        await deliverStaleApprovalReply({
-          scenario: "request_pending_guardian",
-          sourceChannel,
-          replyCallbackUrl,
-          chatId: conversationExternalId,
-          assistantId,
-          approvalCopyGenerator,
-          logger: log,
-          errorLogMessage:
-            "Failed to deliver guardian-pending notice to requester",
-          errorLogContext: { conversationId },
-          ephemeralUserId: slackEphemeralUserId(sourceChannel, actorExternalId),
-        });
-        return { handled: true, type: "assistant_turn" };
-      }
-
-      // Check for an expired-but-unresolved guardian approval. If the approval
-      // expired without a guardian decision, auto-deny and transition
-      // the approval to 'expired'. Without this, the requester could bypass
-      // guardian-only controls by simply waiting for the TTL to elapse.
-      const unresolvedApproval = getUnresolvedApprovalForRequest(
-        pending[0].requestId,
-      );
-      if (unresolvedApproval) {
-        updateApprovalDecision(unresolvedApproval.id, { status: "expired" });
-
-        // Auto-deny the underlying request so it does not remain actionable
-        const expiredDecision: ApprovalDecisionResult = {
-          action: "reject",
-          source: "plain_text",
-        };
-        await handleChannelDecision(conversationId, expiredDecision);
-
-        await deliverStaleApprovalReply({
-          scenario: "guardian_expired_requester",
-          sourceChannel,
-          replyCallbackUrl,
-          chatId: conversationExternalId,
-          assistantId,
-          approvalCopyGenerator,
-          logger: log,
-          errorLogMessage:
-            "Failed to deliver guardian-expiry notice to requester",
-          extraContext: { toolName: pending[0].toolName },
-          errorLogContext: { conversationId },
-          ephemeralUserId: slackEphemeralUserId(sourceChannel, actorExternalId),
-        });
-        return { handled: true, type: "decision_applied" };
-      }
-
-      // Guard: non-guardian actors with a guardian binding must not self-approve
-      // even when no guardian approval row exists yet. The guardian approval
-      // row is created asynchronously when the approval prompt is delivered
-      // to the guardian. In the window between the pending confirmation being
-      // created (isInteractive=true) and the guardian approval row being
-      // persisted, any non-guardian actor could otherwise fall through to the
-      // standard conversational engine / legacy parser and resolve their own
-      // pending request via handleChannelDecision.
+      // Guard: a non-guardian actor with a guardian binding must not
+      // self-approve, even in the window before the guardian's canonical
+      // request row is persisted. The pending confirmation (isInteractive=true)
+      // can exist before the request is delivered to the guardian; without this
+      // guard the actor could fall through to the conversational engine / NL
+      // parser below and resolve their own pending request via
+      // handleChannelDecision.
       if (
         !resolveCapabilities(trustCtx.trustClass).canSelfApproveTools &&
         trustCtx.guardianExternalUserId
@@ -415,7 +154,7 @@ export async function handleApprovalInterception(
             conversationExternalId,
             guardianExternalUserId: trustCtx.guardianExternalUserId,
           },
-          "Blocking non-guardian self-approval: pending confirmation exists but guardian approval row not yet created",
+          "Blocking non-guardian self-approval: pending confirmation exists but canonical guardian request not yet created",
         );
         await deliverStaleApprovalReply({
           scenario: "request_pending_guardian",
@@ -593,7 +332,7 @@ function editStaleSlackApprovalMessage(params: {
   conversationId: string;
 }): void {
   const statusText = "This approval request has been resolved.";
-  const blocks = [
+  const blocks: KnownBlock[] = [
     {
       type: "section",
       text: { type: "mrkdwn", text: statusText },

package/src/runtime/routes/inbound-message-handler.ts

@@ -24,6 +24,7 @@ import {
 } from "../../channels/types.js";
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
+import { channelStatusToMemberStatus } from "../../contacts/member-status.js";
 import {
   createApprovalConversationGenerator,
   createApprovalCopyGenerator,
@@ -92,14 +93,11 @@ import { truncate } from "../../util/truncate.js";
 import { notifyGuardianOfAccessRequest } from "../access-request-helper.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { deliverChannelReply } from "../gateway-client.js";
-import { resolveTrustContext } from "../trust-context-resolver.js";
+import { trustContextFromVerdict } from "../trust-verdict-consumer.js";
 import { canonicalChannelAssistantId } from "./channel-route-shared.js";
 import { BadRequestError } from "./errors.js";
 import { handleApprovalInterception } from "./guardian-approval-interception.js";
-import {
-  channelStatusToMemberStatus,
-  enforceIngressAcl,
-} from "./inbound-stages/acl-enforcement.js";
+import { enforceIngressAcl } from "./inbound-stages/acl-enforcement.js";
 import { enforceAdmissionPolicy } from "./inbound-stages/admission-policy.js";
 import { processChannelMessageInBackground } from "./inbound-stages/background-dispatch.js";
 import { handleBootstrapIntercept } from "./inbound-stages/bootstrap-intercept.js";
@@ -717,17 +715,24 @@ export async function handleChannelInbound({
   }
 
   // ── Actor role resolution ──
-  // Uses shared channel-agnostic resolution so all ingress paths classify
-  // guardian vs non-guardian actors the same way.
+  // Built from the gateway-stamped trust verdict (ACL + identity). An absent
+  // verdict is already hard-denied upstream in enforceIngressAcl; the synthetic
+  // unknown ctx here only guards non-ACL metadata use on that unreachable path.
+  const inboundVerdict = sourceMetadata?.trustVerdict;
   const trustCtx: TrustContext = attachSlackRequesterTimezone(
-    resolveTrustContext({
-      assistantId: canonicalAssistantId,
-      sourceChannel,
-      conversationExternalId,
-      actorExternalId: rawSenderId,
-      actorUsername: body.actorUsername,
-      actorDisplayName: body.actorDisplayName,
-    }),
+    inboundVerdict
+      ? trustContextFromVerdict(inboundVerdict, {
+          sourceChannel,
+          conversationExternalId,
+          actorUsername: body.actorUsername,
+          actorDisplayName: body.actorDisplayName,
+        })
+      : {
+          sourceChannel,
+          trustClass: "unknown",
+          requesterExternalUserId: canonicalSenderId ?? undefined,
+          requesterChatId: conversationExternalId,
+        },
     slackActorTimezone,
   );