@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/daemon/disk-pressure-guard.ts

@@ -202,12 +202,12 @@ export function stopDiskPressureGuard(): void {
   state.timer = null;
 }
 
-export function evaluateDiskPressureNow(): DiskPressureStatus {
+export async function evaluateDiskPressureNow(): Promise<DiskPressureStatus> {
   ensureEnabledStatus();
 
-  let usageInfo: ReturnType<typeof getDiskUsageInfo>;
+  let usageInfo: Awaited<ReturnType<typeof getDiskUsageInfo>>;
   try {
-    usageInfo = getDiskUsageInfo();
+    usageInfo = await getDiskUsageInfo();
   } catch (error) {
     return replaceStatus(sampleFailureStatus(error));
   }

package/src/daemon/doordash-steps.ts

@@ -6,8 +6,8 @@
  */
 
 import { isPlainObject } from "../util/object.js";
+import type { Conversation } from "./conversation.js";
 import type { CardSurfaceData } from "./message-protocol.js";
-import type { ToolSetupContext } from "./tool-setup-types.js";
 
 interface DoordashStep {
   label: string;
@@ -102,7 +102,7 @@ function updateDoordashSteps(
 
 // ── Helpers for reading/writing the task_progress surface ─────────────
 
-function getStoredSteps(ctx: ToolSetupContext): DoordashStep[] | null {
+function getStoredSteps(ctx: Conversation): DoordashStep[] | null {
   const stored = ctx.surfaceState.get(SURFACE_ID);
   if (!stored || stored.surfaceType !== "card") {
     return null;
@@ -116,7 +116,7 @@ function getStoredSteps(ctx: ToolSetupContext): DoordashStep[] | null {
 }
 
 function pushStepsUpdate(
-  ctx: ToolSetupContext,
+  ctx: Conversation,
   updatedSteps: DoordashStep[],
 ): void {
   const stored = ctx.surfaceState.get(SURFACE_ID);
@@ -160,7 +160,7 @@ export function isDoordashCommand(
  * before the command runs.
  */
 export function markDoordashStepInProgress(
-  ctx: ToolSetupContext,
+  ctx: Conversation,
   input: Record<string, unknown>,
 ): void {
   const cmd = input.command as string | undefined;
@@ -190,7 +190,7 @@ export function markDoordashStepInProgress(
  * DoorDash CLI command, then update step statuses based on the result.
  */
 export function updateDoordashProgress(
-  ctx: ToolSetupContext,
+  ctx: Conversation,
   input: Record<string, unknown>,
   isError: boolean,
 ): void {

package/src/daemon/external-plugins-bootstrap.ts

@@ -60,6 +60,7 @@ import {
   unregisterPluginInjectors,
 } from "../plugins/injector-registry.js";
 import { registerDeclaredCredentialKeyPatterns } from "../plugins/mtime-cache.js";
+import { runInPluginContext } from "../plugins/plugin-execution-context.js";
 import { getRegisteredPlugins, unregisterPlugin } from "../plugins/registry.js";
 import {
   type Plugin,
@@ -318,7 +319,12 @@ async function initializePlugin(
 
     if (plugin.hooks?.[HOOKS.INIT]) {
       try {
-        await plugin.hooks[HOOKS.INIT](initContext);
+        // Marked in context for the same reason `runPluginPipeline` marks
+        // every other hook: host APIs the hook reaches (resolveCredential,
+        // resolveWebhookUrl) scope to the calling plugin.
+        await runInPluginContext(name, () =>
+          plugin.hooks![HOOKS.INIT]!(initContext),
+        );
       } catch (err) {
         throw new PluginExecutionError(
           `plugin ${name} init() failed: ${

package/src/daemon/handlers/config-channels.ts

@@ -41,6 +41,7 @@ import {
 } from "../../runtime/channel-verification-service.js";
 import {
   cancelOutbound,
+  deliverVerificationDiscord,
   deliverVerificationSlack,
   deliverVerificationTelegram,
   DESTINATION_RATE_WINDOW_MS,
@@ -48,8 +49,7 @@ import {
   normalizeTelegramDestination,
 } from "../../runtime/verification-outbound-actions.js";
 import {
-  composeVerificationSlack,
-  composeVerificationTelegram,
+  composeVerificationText,
   GUARDIAN_VERIFY_TEMPLATE_KEYS,
 } from "../../runtime/verification-templates.js";
 import { getTelegramBotUsername } from "../../telegram/bot-username.js";
@@ -209,7 +209,10 @@ export async function getVerificationStatus(
   // restart and detect bootstrap completion.
   const [pendingSession, activeOutboundSession] = await Promise.all([
     getPendingSession(resolvedChannel),
-    findActiveSession(resolvedChannel),
+    // The guardian's own session. A channel can carry one per person
+    // verifying, so an unscoped read would report a requester's session as
+    // the guardian's pending verification.
+    findActiveSession(resolvedChannel, { verificationPurpose: "guardian" }),
   ]);
   const hasPendingChallenge = pendingSession != null;
   const outboundFields: Record<string, unknown> = {};
@@ -327,6 +330,8 @@ function toVerificationChannel(channelType: string): ChannelId | null {
       return "telegram";
     case "slack":
       return "slack";
+    case "discord":
+      return "discord";
     default:
       return null;
   }
@@ -423,7 +428,7 @@ export async function verifyTrustedContact(
         verificationPurpose: "trusted_contact",
       });
 
-      const telegramBody = composeVerificationTelegram(
+      const telegramBody = composeVerificationText(
         GUARDIAN_VERIFY_TEMPLATE_KEYS.TELEGRAM_CHALLENGE_REQUEST,
         {
           code: sessionResult.secret,
@@ -507,7 +512,7 @@ export async function verifyTrustedContact(
       verificationPurpose: "trusted_contact",
     });
 
-    const slackBody = composeVerificationSlack(
+    const slackBody = composeVerificationText(
       GUARDIAN_VERIFY_TEMPLATE_KEYS.SLACK_CHALLENGE_REQUEST,
       {
         code: sessionResult.secret,
@@ -529,6 +534,44 @@ export async function verifyTrustedContact(
     };
   }
 
+  // --- Discord verification ---
+  if (verificationChannel === "discord") {
+    const discordUserId = channel.address;
+
+    // Only the user snowflake is an identity. A Discord contact's
+    // `externalChatId` is set only when the assistant has already seen them in
+    // a DM, so it is absent for everyone first met in a guild, and the guild
+    // channel is a room rather than a person either way.
+    const sessionResult = await createOutboundSession({
+      channel: verificationChannel,
+      expectedExternalUserId: discordUserId,
+      identityBindingStatus: "bound",
+      destinationAddress: discordUserId,
+      verificationPurpose: "trusted_contact",
+    });
+
+    const discordBody = composeVerificationText(
+      GUARDIAN_VERIFY_TEMPLATE_KEYS.DISCORD_TRUSTED_CONTACT_CHALLENGE,
+      {
+        code: sessionResult.secret,
+        expiresInMinutes: Math.floor(SESSION_TTL_SECONDS / 60),
+      },
+    );
+
+    const now = Date.now();
+    const sendCount = 1;
+    await updateSessionDelivery(sessionResult.sessionId, now, sendCount, null);
+    deliverVerificationDiscord(discordUserId, discordBody, assistantId);
+
+    return {
+      success: true,
+      verificationSessionId: sessionResult.sessionId,
+      expiresAt: sessionResult.expiresAt,
+      sendCount,
+      channel: verificationChannel,
+    };
+  }
+
   // --- Phone verification ---
   if (verificationChannel === "phone") {
     const normalizedPhone = normalizePhoneNumber(destination);

package/src/daemon/handlers/conversation-history.ts

@@ -22,7 +22,7 @@ export async function performConversationSearch(
 ) {
   // Treat "*" as a list-all wildcard — FTS treats it as a literal character.
   if (params.query.trim() === "*") {
-    const rows = listConversations(params.limit);
+    const rows = listConversations({ limit: params.limit });
     return rows.map((r) => ({
       conversationId: r.id,
       conversationTitle: r.title,

package/src/daemon/handlers/conversations.ts

@@ -3,7 +3,7 @@ import { decideGuardianRequest } from "../../channels/gateway-guardian-requests.
 import {
   clearAll,
   getConversation,
-  isHiddenMessageMetadata,
+  isSuppressedQueuedMessage,
 } from "../../persistence/conversation-crud.js";
 import { resolveConversationId } from "../../persistence/conversation-key-store.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
@@ -13,6 +13,7 @@ import { getSubagentManager } from "../../subagent/index.js";
 import { createAbortReason } from "../../util/abort-reasons.js";
 import { UserError } from "../../util/errors.js";
 import { touchConversation } from "../conversation-evictor.js";
+import { forceClearStaleProcessing } from "../conversation-lifecycle.js";
 import {
   buildSlashContext,
   formatCleanResult,
@@ -242,16 +243,18 @@ export async function resolveMetaSlashCommand(
 // ---------------------------------------------------------------------------
 
 /**
- * Whether the caller behind a delete request may cancel this queued message.
+ * Whether the caller may cancel or steer to this queued message.
  *
  * A queued message records the verified requester that enqueued it
- * (`sourceActorPrincipalId`); the delete route receives the caller's verified
- * identity in the `x-vellum-actor-principal-id` header, which both adapters
- * derive from the auth context rather than from anything the caller sent. When
- * both are present they must match: `message_queued` is broadcast to every
- * subscriber of the assistant, so every requestId in a conversation is visible
- * to every connected client, and without this check one actor principal could
- * cancel another's pending message just by echoing the id back.
+ * (`sourceActorPrincipalId`); the delete and steer routes receive the caller's
+ * verified identity in the `x-vellum-actor-principal-id` header, which both
+ * adapters derive from the auth context rather than from anything the caller
+ * sent. When both are present they must match: `message_queued` is broadcast
+ * to every subscriber of the assistant, so every requestId in a conversation
+ * is visible to every connected client, and without this check one actor
+ * principal could cancel another's pending message, or abort the live
+ * generation and jump another's message to the head of the queue, just by
+ * echoing the id back.
  *
  * Two cases stay open, both deliberately:
  *
@@ -263,7 +266,7 @@ export async function resolveMetaSlashCommand(
  *   wake, subagent notifications, surface actions) have no enqueuing actor to
  *   compare against, and cancelling one from the queue UI is intended.
  */
-function mayCancelQueuedMessage(
+function mayActOnQueuedMessage(
   queued: QueuedMessage,
   callerActorPrincipalId: string | undefined,
 ): boolean {
@@ -281,7 +284,9 @@ function mayCancelQueuedMessage(
  * `message_queued_deleted`. It is the counterpart to the `message_queued` ack
  * and the only signal that closes out a queued row that never runs: without it
  * a client that didn't originate the delete leaves the pending indicator up
- * forever, since no `message_dequeued` is ever coming. Hidden sends are
+ * forever, since no `message_dequeued` is ever coming. Rows with no
+ * client-visible queued counterpart ({@link isSuppressedQueuedMessage} —
+ * hidden sends and daemon-injected subagent/ACP/wake notifications) are
  * suppressed for the same reason they get no ack: they have no client row to
  * close.
  */
@@ -311,7 +316,7 @@ export function deleteQueuedMessage(
     );
     return { removed: false, reason: "message_not_found" };
   }
-  if (!mayCancelQueuedMessage(queued, options.actorPrincipalId)) {
+  if (!mayActOnQueuedMessage(queued, options.actorPrincipalId)) {
     log.warn(
       {
         conversationId,
@@ -323,7 +328,12 @@ export function deleteQueuedMessage(
     return { removed: false, reason: "forbidden" };
   }
   conversation.removeQueuedMessage(requestId);
-  if (!isHiddenMessageMetadata(queued.metadata)) {
+  // Queue events come in pairs, so an entry that never produced a
+  // `message_queued` ack (a suppressed daemon-injected send, or a hidden
+  // machine send) must not produce a delete either: clients have no row to
+  // retire and an unpaired event would decrement a counter that was never
+  // incremented.
+  if (!isSuppressedQueuedMessage(queued.metadata)) {
     queued.onEvent({
       type: "message_queued_deleted",
       conversationId,
@@ -347,11 +357,16 @@ export function deleteQueuedMessage(
 export function steerToMessage(
   conversationId: string,
   requestId: string,
+  options: { actorPrincipalId?: string } = {},
 ):
   | { steered: true }
   | {
       steered: false;
-      reason: "conversation_not_found" | "message_not_found" | "not_processing";
+      reason:
+        | "conversation_not_found"
+        | "message_not_found"
+        | "not_processing"
+        | "forbidden";
     } {
   const conversation = findConversation(conversationId);
   if (!conversation) {
@@ -370,6 +385,26 @@ export function steerToMessage(
     return { steered: false, reason: "not_processing" };
   }
 
+  const queued = conversation.queue.findByRequestId(requestId);
+  if (!queued) {
+    log.warn(
+      { conversationId, requestId },
+      "Queued message not found for steering",
+    );
+    return { steered: false, reason: "message_not_found" };
+  }
+  if (!mayActOnQueuedMessage(queued, options.actorPrincipalId)) {
+    log.warn(
+      {
+        conversationId,
+        requestId,
+        callerActorPrincipalId: options.actorPrincipalId,
+      },
+      "Refusing to steer to a queued message enqueued by a different actor principal",
+    );
+    return { steered: false, reason: "forbidden" };
+  }
+
   const promoted = conversation.queue.promoteToHead(requestId);
   if (!promoted) {
     log.warn(
@@ -396,16 +431,26 @@ export function steerToMessage(
     "Steering to queued message — aborting current generation",
   );
 
-  // Abort the in-flight generation. The agent loop's finally block calls
+  // Abort the in-flight generation. The agent loop's release calls
   // drainQueue, which will pick up the promoted message at the head.
   // Unlike abortConversation, we do NOT clear the queue or dispose
-  // prompters — we want the queue to drain with the promoted message first.
+  // prompters: we want the queue to drain with the promoted message first.
   const reason = createAbortReason(
     "preempted_by_new_message",
     "steerToMessage",
     conversationId,
   );
-  conversation.abortController?.abort(reason);
+  if (conversation.abortController) {
+    conversation.abortController.abort(reason);
+  } else {
+    // Processing is latched with no live turn to abort, so nothing is going to
+    // reach a drain on its own and the message promoted above would sit at the
+    // head of a queue that never runs. Release the flag and drain here instead.
+    // `pendingSteerRepair` stays set: the drain consumes it, repairing any
+    // tool_use blocks the dead turn stranded before the promoted head runs.
+    forceClearStaleProcessing(conversation, "steerToMessage");
+    void conversation.kickDrainQueue("loop_complete", "steer_force_clear");
+  }
   // Deny pending confirmations so the abort unblocks immediately.
   conversation.denyAllPendingConfirmations();
 

package/src/daemon/handlers/shared.ts

@@ -4,6 +4,7 @@ import {
 } from "@vellumai/service-contracts/redacted-credential";
 import { v4 as uuid } from "uuid";
 
+import { AnsweredQuestionSchema } from "../../api/events/question-answered.js";
 import type {
   ConversationContentBlock,
   ConversationMessageAttachment,
@@ -636,6 +637,17 @@ export function renderHistoryContent(
         entry.activityMetadata =
           block._activityMetadata as HistoryToolCall["activityMetadata"];
       }
+      // Read back the answered `ask_question` record so the answered card
+      // rehydrates from history. Validated (rather than trusted like the
+      // sibling riders) because the card renders its contents directly: a
+      // malformed rider from a hand-edited or partially-written row must
+      // degrade to no card, not to a crashing render.
+      const answeredQuestion = AnsweredQuestionSchema.safeParse(
+        block._answeredQuestion,
+      );
+      if (answeredQuestion.success) {
+        entry.answeredQuestion = answeredQuestion.data;
+      }
       toolCalls.push(entry);
       if (id) {
         pendingToolUses.set(id, entry);

package/src/daemon/handlers/skills.ts

@@ -646,6 +646,16 @@ function findSkillById(
   return { item, summary: r.summary };
 }
 
+/**
+ * Whether a skill currently resolves locally (bundled, managed, workspace, or
+ * extra). Callers that serve data ABOUT a skill use this to keep to the same
+ * current-resource boundary as the file routes, so a deleted skill stops
+ * answering even when durable artifacts about it survive elsewhere.
+ */
+export function skillExistsLocally(skillId: string): boolean {
+  return findSkillById(skillId) !== undefined;
+}
+
 export async function getSkill(
   skillId: string,
 ): Promise<{ skill: SkillDetailResponse } | { error: string; status: number }> {
@@ -1340,7 +1350,7 @@ export async function installSkill(spec: {
       skillId = result.skillId;
 
       const stagedSkillDir = result.skillDir;
-      installSkillDependenciesIfPresent(stagedSkillDir);
+      await installSkillDependenciesIfPresent(stagedSkillDir);
       commitStagedSkillInstall(skillId, stagedSkillDir);
     } finally {
       rmSync(clawhubProjectRoot, { recursive: true, force: true });

package/src/daemon/identity-helpers.ts

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { resolveGuardianPersonaStrict } from "../prompts/persona-resolver.js";
+import { DECLINED_BY_USER_SENTINEL } from "../prompts/user-reference.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
 
 /** Read the assistant's name from IDENTITY.md for personalized responses. */
@@ -19,19 +21,45 @@ export function getAssistantName(): string | null {
 }
 
 /**
- * Read the guardian's display name from `users/default.md`. We look for the
- * markdown-bold "Name" label (matching the IDENTITY.md convention) and fall
- * back to `null` on any miss; callers substitute a generic label.
+ * Extract a display name from persona-file content. Tries the markdown-bold
+ * "Name" label (the IDENTITY.md convention), then the onboarding-written
+ * "Preferred name" bullet, then the scaffold's "Preferred name/reference"
+ * line. Matches only horizontal whitespace after the label so an unfilled
+ * scaffold line does not swallow the next line.
  */
-export function resolveUserName(workspaceDir: string): string | null {
+function extractPersonaName(content: string): string | null {
+  const match =
+    content.match(/\*\*Name:\*\*[ \t]*(.+)/) ??
+    content.match(/\*\*Preferred name:\*\*[ \t]*(.+)/) ??
+    content.match(/Preferred name\/reference:[ \t]*(.+)/);
+  return match?.[1]?.trim() || null;
+}
+
+function readPersonaName(filePath: string): string | null {
   try {
-    const content = readFileSync(
-      join(workspaceDir, "users", "default.md"),
-      "utf-8",
-    );
-    const match = content.match(/\*\*Name:\*\*\s*(.+)/);
-    return match?.[1]?.trim() || null;
+    return extractPersonaName(readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
 }
+
+/**
+ * Read the user's display name from the guardian's persona file
+ * (`users/<slug>.md`, resolved via the guardian-delivery binding), falling
+ * back to `users/default.md`. Returns `null` on any miss; callers substitute
+ * a generic label.
+ *
+ * The guardian resolution reads the sync in-process guardian-delivery cache;
+ * callers in processes that do not otherwise warm it (memory worker) await
+ * `getGuardianDelivery` first.
+ */
+export function resolveUserName(workspaceDir: string): string | null {
+  const guardianContent = resolveGuardianPersonaStrict();
+  if (guardianContent) {
+    const name = extractPersonaName(guardianContent);
+    if (name && name !== DECLINED_BY_USER_SENTINEL) {
+      return name;
+    }
+  }
+  return readPersonaName(join(workspaceDir, "users", "default.md"));
+}