@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

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

@@ -10,7 +10,10 @@ import {
   createAssistantMessage,
   createUserMessage,
 } from "../../agent/message-types.js";
-import { ConversationMessageSchema } from "../../api/responses/conversation-message.js";
+import {
+  type ConversationContentBlock,
+  ConversationMessageSchema,
+} from "../../api/responses/conversation-message.js";
 import {
   CHANNEL_IDS,
   INTERFACE_IDS,
@@ -47,6 +50,7 @@ import {
   getCannedFirstGreeting,
   isWakeUpGreeting,
 } from "../../daemon/first-greeting.js";
+import { supersedePendingInteractionsOnEnqueue } from "../../daemon/handlers/conversations.js";
 import {
   collectAttachmentRefs,
   type HistoryAttachmentRef,
@@ -64,6 +68,7 @@ import type {
   HostProxyTransportMetadata,
   NonHostProxyTransportMetadata,
 } from "../../daemon/message-types/conversations.js";
+import type { TrustContext } from "../../daemon/trust-context.js";
 import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
 import {
   writeOnboardingSidecar,
@@ -117,30 +122,27 @@ import {
 } from "../../util/platform.js";
 import { silentlyWithLog } from "../../util/silently.js";
 import { assistantEventHub, broadcastMessage } from "../assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
 import { getPersistedSeq } from "../assistant-stream-state.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   type GuardianPendingScope,
   routeGuardianReply,
 } from "../guardian-reply-router.js";
-import { healGuardianBindingDrift } from "../guardian-vellum-migration.js";
+import { reResolveTrustOnResetDrift } from "../guardian-vellum-migration.js";
 import type {
   ApprovalConversationGenerator,
   RuntimeAttachmentMetadata,
   RuntimeMessagePayload,
   SendMessageDeps,
 } from "../http-types.js";
-import { resolveLocalTrustContext } from "../local-actor-identity.js";
+import { findLocalGuardianPrincipalId } from "../local-actor-identity.js";
+import { resolveLocalPrincipalTrustContext } from "../local-principal-trust.js";
 import * as pendingInteractions from "../pending-interactions.js";
 import {
   publishConversationListAndMetadataChanged,
   publishConversationMessagesChanged,
 } from "../sync/resource-sync-events.js";
-import {
-  resolveTrustContext,
-  withSourceChannel,
-} from "../trust-context-resolver.js";
+import { withSourceChannel } from "../trust-context-resolver.js";
 import {
   BadRequestError,
   InternalError,
@@ -943,6 +945,27 @@ export function handleListMessages({
         .filter((block) => block.type !== "text" || block.text.length > 0);
     }
 
+    // Ensure every hydrated attachment has a corresponding content block.
+    // renderHistoryContent inlines attachment blocks only when it has
+    // file-block refs with matching DB rows; directives (assistant-authored
+    // <vellum-attachment/> tags) don't leave a file block after stripping,
+    // so their attachments end up in the flat `attachments` array but not in
+    // `contentBlocks`. Append any that are missing so the canonical
+    // projection is complete.
+    const existingAttachmentIds = new Set(
+      contentBlocks
+        .filter(
+          (b): b is Extract<ConversationContentBlock, { type: "attachment" }> =>
+            b.type === "attachment",
+        )
+        .map((b) => b.attachment.id),
+    );
+    for (const att of msgAttachments) {
+      if (!existingAttachmentIds.has(att.id)) {
+        contentBlocks.push({ type: "attachment", attachment: att });
+      }
+    }
+
     const alignedContentOrder = aligned.rewriteContentOrder(contentOrder);
 
     // Use sentAt (actual event time) for the display timestamp when available,
@@ -971,7 +994,7 @@ export function handleListMessages({
       ...(alignedContentOrder.length > 0
         ? { contentOrder: alignedContentOrder }
         : {}),
-      ...(contentBlocks.length > 0 ? { contentBlocks } : {}),
+      contentBlocks,
       ...(m.subagentNotification
         ? { subagentNotification: m.subagentNotification }
         : {}),
@@ -1419,56 +1442,65 @@ export async function handleSendMessage(
     conversation.setOnboardingContext(body.onboarding!);
   }
 
-  // Resolve guardian context from the AuthContext's actorPrincipalId.
-  // The JWT-verified principal is used as the sender identity through
-  // the same trust resolution pipeline that channel ingress uses.
+  // Resolve guardian context from the AuthContext's actorPrincipalId via the
+  // gateway guardian binding: a vellum principal is the guardian or nobody.
   if (actorPrincipalId) {
     // Dev bypass (HTTP auth disabled): the synthetic "dev-bypass" principal
-    // won't match any guardian binding. Resolve from the local guardian
-    // binding instead, which produces the correct guardian trust context.
+    // won't match any guardian binding. Resolve the real guardian principal and
+    // map that through, failing closed to unknown on an empty gateway.
     if (isHttpAuthDisabled() && actorPrincipalId === "dev-bypass") {
-      conversation.setTrustContext(resolveLocalTrustContext(sourceChannel));
+      const guardianPrincipalId = await findLocalGuardianPrincipalId();
+      let trustCtx: TrustContext = guardianPrincipalId
+        ? withSourceChannel(
+            sourceChannel,
+            await resolveLocalPrincipalTrustContext({
+              actorPrincipalId: guardianPrincipalId,
+              sourceChannel: "vellum",
+              conversationExternalId: "local",
+            }),
+          )
+        : { trustClass: "unknown", sourceChannel };
+      if (guardianPrincipalId && trustCtx.trustClass === "unknown") {
+        const healed = await reResolveTrustOnResetDrift(
+          guardianPrincipalId,
+          sourceChannel,
+        );
+        if (healed) trustCtx = healed;
+      }
+      conversation.setTrustContext(trustCtx);
     } else {
-      const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
-      let trustCtx = resolveTrustContext({
-        assistantId,
-        sourceChannel: "vellum",
-        conversationExternalId: "local",
-        actorExternalId: actorPrincipalId,
-      });
+      let trustCtx = withSourceChannel(
+        sourceChannel,
+        await resolveLocalPrincipalTrustContext({
+          actorPrincipalId,
+          sourceChannel: "vellum",
+          conversationExternalId: "local",
+        }),
+      );
       if (trustCtx.trustClass === "unknown") {
-        // Attempt to heal guardian binding drift: after a DB reset the
-        // guardian binding gets a new vellum-principal-* UUID while the
-        // client still holds a valid JWT with the old one. The signing
-        // key survives the reset, so the JWT is authentic — just stale.
-        const healed = healGuardianBindingDrift(actorPrincipalId);
-        if (healed) {
-          trustCtx = resolveTrustContext({
-            assistantId,
-            sourceChannel: "vellum",
-            conversationExternalId: "local",
-            actorExternalId: actorPrincipalId,
-          });
+        const healed = await reResolveTrustOnResetDrift(
+          actorPrincipalId,
+          sourceChannel,
+        );
+        if (healed && healed.trustClass !== "unknown") {
+          trustCtx = healed;
           log.info(
-            {
-              actorPrincipalId: actorPrincipalId,
-              trustClass: trustCtx.trustClass,
-            },
-            "Trust re-resolved after guardian binding drift heal",
+            { actorPrincipalId, trustClass: trustCtx.trustClass },
+            "Trust re-resolved from local mirror after gateway returned unknown",
           );
         } else {
           log.warn(
             {
-              actorPrincipalId: actorPrincipalId,
+              actorPrincipalId,
               sourceChannel,
-              trustClass: trustCtx.trustClass,
-              principalType: principalType,
+              trustClass: "unknown",
+              principalType,
             },
             "JWT-verified actor resolved to unknown trust class — possible guardian binding drift (e.g. DB reset without re-bootstrap)",
           );
         }
       }
-      conversation.setTrustContext(withSourceChannel(sourceChannel, trustCtx));
+      conversation.setTrustContext(trustCtx);
     }
   } else {
     // Service principals (svc_gateway) or tokens without an actor ID
@@ -1793,29 +1825,11 @@ export async function handleSendMessage(
     // the client showing "Failed to send" for a message the daemon will
     // process from the queue.
     try {
-      if (conversation.hasAnyPendingConfirmation()) {
-        // Emit authoritative denial state for each pending request.
-        // sendToClient (wired to the SSE hub) delivers these to the client.
-        for (const interaction of pendingInteractions.getByConversation(
-          mapping.conversationId,
-        )) {
-          if (interaction.kind === "confirmation") {
-            conversation.emitConfirmationStateChanged({
-              conversationId: mapping.conversationId,
-              requestId: interaction.requestId,
-              state: "denied" as const,
-              source: "auto_deny" as const,
-            });
-            // Sync canonical guardian request status so stale "pending" DB
-            // records don't get matched by later guardian reply routing.
-            resolveCanonicalGuardianRequest(interaction.requestId, "pending", {
-              status: "denied",
-            });
-          }
-        }
-        conversation.denyAllPendingConfirmations();
-        pendingInteractions.removeByConversation(mapping.conversationId);
-      }
+      // Supersede interactions left pending by the in-flight turn: auto-deny
+      // confirmations (with canonical/client sync) and steer to the enqueued
+      // message if an ask_question is parked. Centralized so the CLI signal
+      // path (signals/user-message.ts) gets identical handling.
+      supersedePendingInteractionsOnEnqueue(mapping.conversationId, requestId);
 
       // Expire any orphaned canonical requests that survived without a
       // matching in-memory pending interaction (e.g. prompter timeouts).

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/events-routes.ts

@@ -43,7 +43,7 @@ import type { ReplaySubscriber } from "../assistant-stream-state.js";
 import { getReplayWindow } from "../assistant-stream-state.js";
 import { ACTOR_PRINCIPALS, GATEWAY_PRINCIPALS } from "../auth/route-policy.js";
 import { DEFAULT_HEARTBEAT_INTERVAL_MS } from "../client-health.js";
-import { resolveActorPrincipalIdForLocalGuardian } from "../local-actor-identity.js";
+import { resolveActorPrincipalIdForLocalGuardianSync } from "../local-actor-identity.js";
 import {
   BadRequestError,
   NotFoundError,
@@ -311,7 +311,7 @@ export function handleSubscribeAssistantEvents(
   // bearer token's AuthContext. May be absent for legacy / service-token
   // connections that have no principal. See `resolveActorPrincipalId` for the
   // dev-bypass translation rationale.
-  const actorPrincipalId = resolveActorPrincipalIdForLocalGuardian(
+  const actorPrincipalId = resolveActorPrincipalIdForLocalGuardianSync(
     rawActorPrincipalId?.trim() || undefined,
   );
 

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/host-app-control-routes.ts

@@ -39,7 +39,7 @@ const VALID_STATES: ReadonlySet<HostAppControlState> = new Set([
 // POST /v1/host-app-control-result
 // ---------------------------------------------------------------------------
 
-function handleHostAppControlResult({ body, headers }: RouteHandlerArgs) {
+async function handleHostAppControlResult({ body, headers }: RouteHandlerArgs) {
   if (!body || typeof body !== "object") {
     throw new BadRequestError("Request body is required");
   }
@@ -95,9 +95,10 @@ function handleHostAppControlResult({ body, headers }: RouteHandlerArgs) {
         `Client "${submittingClientId}" is not the target for this request (expected "${peeked.targetClientId}"). The targeted client must submit the result.`,
       );
     }
-    const submittingActorPrincipalId = resolveActorPrincipalIdForLocalGuardian(
-      headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
-    );
+    const submittingActorPrincipalId =
+      await resolveActorPrincipalIdForLocalGuardian(
+        headerMap["x-vellum-actor-principal-id"]?.trim() || undefined,
+      );
     enforceSameActorOrThrow({
       sourceActorPrincipalId: submittingActorPrincipalId,
       targetActorPrincipalId: peeked.targetActorPrincipalId,