@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

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

@@ -163,9 +163,11 @@ function handleQuestionResponse({ body }: RouteHandlerArgs) {
     "Question resolved",
   );
 
-  (interaction.rpcResolve as
-    | ((value: QuestionPromptResult) => void)
-    | undefined)?.(result);
+  (
+    interaction.rpcResolve as
+      | ((value: QuestionPromptResult) => void)
+      | undefined
+  )?.(result);
 
   return { success: true };
 }
@@ -233,7 +235,9 @@ function buildCompletedResult(
 function readBatchMetadata(
   interaction: ReturnType<typeof pendingInteractions.get>,
 ): QuestionBatchMetadata {
-  const meta = interaction?.metadata as Partial<QuestionBatchMetadata> | undefined;
+  const meta = interaction?.metadata as
+    | Partial<QuestionBatchMetadata>
+    | undefined;
   return {
     orderedIds: meta?.orderedIds ?? [],
     optionsById: meta?.optionsById ?? {},

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

@@ -37,22 +37,16 @@ import {
   getScheduleRuns,
   listSchedules,
   type ScheduleJob,
-  setScheduleRunConversationId,
   updateSchedule,
 } from "../../schedule/schedule-store.js";
 import { getScheduleUsageSummaries } from "../../schedule/schedule-usage-store.js";
-import { areCoreToolsInitialized } from "../../tools/registry.js";
+import { initializeTools } from "../../tools/registry.js";
 import { getLogger } from "../../util/logger.js";
 import { normalizeCapabilityManifest } from "../../workflows/capabilities.js";
 import { getWorkflowRunManager } from "../../workflows/run-manager.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { parseEpochMillisRange } from "./epoch-millis-range.js";
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  ServiceUnavailableError,
-} from "./errors.js";
+import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import {
   paginateRuns,
   parseRunsBeforeCursor,
@@ -1008,19 +1002,12 @@ async function handleRunScheduleNow(id: string) {
     if (!schedule.workflowName) {
       throw new BadRequestError("Workflow schedule has no workflowName");
     }
-    // Boot race: resolveCapabilities grants the read-only baseline (file_read,
-    // web_search, …) from the tool registry, which initializeProvidersAndTools()
-    // populates during startup. The scheduler's automatic firing path DEFERS a
-    // workflow trigger to a later tick while `!areCoreToolsInitialized()` so a
-    // run never launches with an empty baseline. A manual "run now" has no later
-    // tick to defer to, so fail fast with a retryable 503 rather than launch a
-    // degraded run; the window is just the few seconds of assistant boot.
-    if (!areCoreToolsInitialized()) {
-      throw new ServiceUnavailableError(
-        "The assistant is still starting up and its tools are not ready yet. " +
-          "Try running this workflow again in a moment.",
-      );
-    }
+    // resolveCapabilities grants the read-only baseline (file_read, web_search,
+    // …) from the tool registry, so the baseline must be registered before the
+    // run launches or it would get an empty toolset. Ensure it — idempotent and
+    // cached, so this is a settled-promise await except in the few-seconds boot
+    // window, where it blocks until the registry is populated.
+    await initializeTools();
     const runId = await createScheduleRun(
       schedule.id,
       `workflow:${schedule.id}`,
@@ -1069,64 +1056,19 @@ async function handleRunScheduleNow(id: string) {
     return handleListSchedules({});
   }
 
-  // Check if message is a task invocation (run_task:<task_id>)
-  const taskMatch = schedule.message.match(/^run_task:(\S+)$/);
-  if (taskMatch) {
-    const taskId = taskMatch[1];
+  // Legacy task-template schedules (message `run_task:<id>`) reference a
+  // capability that has been removed. Record a failed run instead of forwarding
+  // the raw `run_task:<id>` string to the agent.
+  if (/^run_task:\S+$/.test(schedule.message)) {
     const runId = await createScheduleRun(schedule.id, null);
-    try {
-      log.info(
-        { jobId: schedule.id, name: schedule.name, taskId },
-        "Executing scheduled task manually (run now)",
-      );
-      const { runTask } = await import("../../tasks/task-runner.js");
-      const result = await runTask(
-        { taskId, workingDir: process.cwd(), source: "schedule" },
-        async (conversationId, message, taskRunId) => {
-          const conversation = await getOrCreateConversation(conversationId, {
-            trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
-          });
-          conversation.taskRunId = taskRunId;
-          try {
-            await conversation.processMessage({
-              content: message,
-              attachments: [],
-              onEvent: () => {},
-              isInteractive: false,
-              ...(schedule.inferenceProfile
-                ? { overrideProfile: schedule.inferenceProfile }
-                : {}),
-            });
-          } finally {
-            conversation.taskRunId = undefined;
-          }
-        },
-      );
-
-      await setScheduleRunConversationId(runId, result.conversationId);
-      if (result.status === "failed") {
-        await completeScheduleRun(runId, {
-          status: "error",
-          error: result.error ?? "Task run failed",
-        });
-      } else {
-        await completeScheduleRun(runId, { status: "ok" });
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      log.warn(
-        { err, jobId: schedule.id, name: schedule.name, taskId },
-        "Manual scheduled task execution failed",
-      );
-      const fallbackConversation = await bootstrapConversation({
-        source: "schedule",
-        groupId: "system:scheduled",
-        origin: "schedule",
-        systemHint: `Schedule (manual): ${schedule.name}`,
-      });
-      await setScheduleRunConversationId(runId, fallbackConversation.id);
-      await completeScheduleRun(runId, { status: "error", error: message });
-    }
+    await completeScheduleRun(runId, {
+      status: "error",
+      error: "Scheduled task templates are no longer supported.",
+    });
+    log.warn(
+      { jobId: schedule.id, name: schedule.name },
+      "Skipped unsupported task-template schedule (run_task, manual run-now)",
+    );
     return handleListSchedules({});
   }
 

package/src/runtime/routes/schedule-worker-routes.ts

@@ -1,22 +1,16 @@
 /**
  * Schedule worker control endpoints (start / stop / status).
  *
- * These run inside the daemon so the worker process the daemon spawns is a
- * direct child of the daemon — which is what makes it show up in the daemon's
- * process tree (`assistant ps`) and lets the daemon tear it down on shutdown.
- * The `assistant schedules worker` CLI is a thin IPC client over these routes;
- * if it spawned the worker itself, the worker would be parented to the
- * short-lived CLI process (reparented to init) instead of the daemon.
+ * The schedule worker runs as a child process the daemon spawns at startup (so
+ * it shows up in `assistant ps` and is torn down on shutdown). These routes run
+ * inside the daemon so a worker spawned on demand is a direct child of the
+ * daemon too. `start` / `stop` manage the process lifecycle directly (respawn or
+ * SIGTERM); `status` reports its liveness. The `assistant schedules worker` CLI
+ * is a thin IPC client over these routes.
  */
 
 import { z } from "zod";
 
-import {
-  getConfigReadOnly,
-  loadRawConfig,
-  saveRawConfig,
-  setNestedValue,
-} from "../../config/loader.js";
 import {
   probeScheduleWorker,
   ScheduleWorkerSpawnError,
@@ -31,62 +25,31 @@ import type { RouteDefinition } from "./types.js";
 
 const log = getLogger("schedule-worker-routes");
 
-/**
- * Persist `schedules.worker.enabled` to the on-disk config via the shared
- * raw-config helpers, so only this leaf changes (schema defaults are not baked
- * into the file). The daemon's scheduler re-reads the flag on its next tick,
- * so the change takes effect without a restart.
- */
-function setScheduleWorkerEnabled(enabled: boolean): void {
-  const raw = loadRawConfig();
-  setNestedValue(raw, "schedules.worker.enabled", enabled);
-  saveRawConfig(raw);
-}
-
-const workerStatusSchema = z.object({
-  status: z.enum(["running", "not_running"]),
-  pid: z.number().optional(),
-});
-
 const startResponseSchema = z.object({
   pid: z.number(),
   alreadyRunning: z.boolean(),
-  workerEnabled: z.literal(true),
   pidPath: z.string(),
 });
 
 const stopResponseSchema = z.object({
   workerWasRunning: z.boolean(),
   pid: z.number().optional(),
-  workerEnabled: z.literal(false),
 });
 
 const statusResponseSchema = z.object({
   status: z.enum(["running", "not_running"]),
   pid: z.number().optional(),
-  workerEnabled: z.boolean(),
-  inProcessScheduler: workerStatusSchema,
 });
 
 /**
- * Start (or reuse) the schedule worker process as a child of the daemon, then
- * enable `schedules.worker.enabled` so the daemon's scheduler leaves schedule
- * execution to it. The flag is only enabled once the worker is confirmed up —
- * on spawn failure it is left untouched so the in-process scheduler keeps
- * running schedules rather than standing down for a worker that never came
- * up.
+ * Spawn (or reuse) the schedule worker process as a child of the daemon. The
+ * worker is always the sole runner of schedule execution, so a worker that comes
+ * up late is fine — `terminateOnTimeout` is not set.
  */
 async function startScheduleWorker() {
   let result: { pid: number; alreadyRunning: boolean };
   try {
-    // `detached: false` parents the worker to the daemon. `terminateOnTimeout`
-    // matches the leave-the-flag-off-on-failure contract below: a worker that
-    // came up late would otherwise run schedules alongside the in-process
-    // scheduler.
-    result = await spawnScheduleWorkerProcess({
-      detached: false,
-      terminateOnTimeout: true,
-    });
+    result = await spawnScheduleWorkerProcess({ detached: false });
   } catch (err) {
     const message =
       err instanceof ScheduleWorkerSpawnError || err instanceof Error
@@ -96,25 +59,18 @@ async function startScheduleWorker() {
     throw new InternalError(message);
   }
 
-  setScheduleWorkerEnabled(true);
-
   return {
     pid: result.pid,
     alreadyRunning: result.alreadyRunning,
-    workerEnabled: true as const,
     pidPath: getScheduleWorkerPidPath(),
   };
 }
 
 /**
- * Disable `schedules.worker.enabled` (handing schedule execution back to the
- * in-process scheduler) and SIGTERM the worker process if it is running. A
- * worker that is not running is not an error — flipping the flag alone
- * restores in-process execution.
+ * SIGTERM the schedule worker process if it is running. A worker that is not
+ * running is not an error.
  */
 function stopScheduleWorker() {
-  setScheduleWorkerEnabled(false);
-
   let before: ReturnType<typeof stopScheduleWorkerProcess>;
   try {
     before = stopScheduleWorkerProcess();
@@ -127,37 +83,15 @@ function stopScheduleWorker() {
   return {
     workerWasRunning: before.status === "running",
     ...(before.pid != null ? { pid: before.pid } : {}),
-    workerEnabled: false as const,
   };
 }
 
-/**
- * Report the worker process state, the `schedules.worker.enabled` config
- * value, and whether the daemon's own scheduler is currently executing
- * schedules.
- *
- * The in-process scheduler executes schedules exactly when the flag is off
- * (it stands down from claiming while the flag is on). This handler runs
- * inside the daemon — the very process that is (or isn't) the in-process
- * scheduler — so its state is derived directly from config, with the
- * daemon's own PID, rather than read back from a marker file.
- */
+/** Report the schedule worker process liveness from its PID file. */
 function scheduleWorkerStatus() {
   const worker = probeScheduleWorker();
-  const workerEnabled = getConfigReadOnly().schedules.worker.enabled;
-
-  const inProcessScheduler: {
-    status: "running" | "not_running";
-    pid?: number;
-  } = workerEnabled
-    ? { status: "not_running" }
-    : { status: "running", pid: process.pid };
-
   return {
     status: worker.status,
     ...(worker.pid != null ? { pid: worker.pid } : {}),
-    workerEnabled,
-    inProcessScheduler,
   };
 }
 
@@ -173,7 +107,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: startScheduleWorker,
     summary: "Start the schedule worker",
     description:
-      "Spawns (or reuses) the schedule worker process as a child of the daemon and enables schedules.worker.enabled, so scheduled jobs run out of process.",
+      "Spawns (or reuses) the schedule worker process as a child of the daemon.",
     tags: ["system"],
     responseBody: startResponseSchema,
   },
@@ -187,8 +121,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     handler: stopScheduleWorker,
     summary: "Stop the schedule worker",
-    description:
-      "Disables schedules.worker.enabled (handing schedule execution back to the in-process scheduler) and SIGTERMs the schedule worker process if it is running.",
+    description: "SIGTERMs the schedule worker process if it is running.",
     tags: ["system"],
     responseBody: stopResponseSchema,
   },
@@ -202,8 +135,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     handler: scheduleWorkerStatus,
     summary: "Schedule worker status",
-    description:
-      "Reports the schedule worker process state, schedules.worker.enabled, and whether the daemon's in-process scheduler is currently executing schedules.",
+    description: "Reports the schedule worker process liveness.",
     tags: ["system"],
     responseBody: statusResponseSchema,
   },

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

@@ -17,6 +17,7 @@ import {
   setPlatformUserId,
 } from "../../config/env.js";
 import { getConfig, invalidateConfigCache } from "../../config/loader.js";
+import { maybeDefaultSpeechToManaged } from "../../config/managed-speech-defaults.js";
 import { getCesClient } from "../../credential-execution/ces-runtime.js";
 import type { CesClient } from "../../credential-execution/client.js";
 import { evictConversationsForReload } from "../../daemon/conversation-store.js";
@@ -320,6 +321,19 @@ async function handleAddSecret({ body }: RouteHandlerArgs) {
           }
         }
       }
+      if (
+        service === "vellum" &&
+        (field === "assistant_api_key" ||
+          field === "platform_assistant_id" ||
+          field === "platform_base_url")
+      ) {
+        // Managed-speech availability needs the API key, the assistant ID,
+        // and the base URL, and the CLI connect path stores all three
+        // concurrently — fire on each so the last write to land triggers the
+        // defaulting; the hook no-ops until the connection is complete.
+        // Detached — must not block the response.
+        void maybeDefaultSpeechToManaged();
+      }
       log.info({ service, field }, "Credential added via HTTP");
       return { success: true, type, name };
     }

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

@@ -16,11 +16,11 @@ import {
 import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import { loadSkillCatalog } from "../../config/skills.js";
 import { getGuardianDelivery } from "../../contacts/guardian-delivery-reader.js";
+import type { Conversation } from "../../daemon/conversation.js";
 import { findConversation } from "../../daemon/conversation-registry.js";
 import {
   createResolveToolsCallback,
   DEFAULT_PREACTIVATED_SKILL_IDS,
-  type SkillProjectionContext,
 } from "../../daemon/conversation-tool-setup.js";
 import {
   computeGatewayTarget,
@@ -487,8 +487,8 @@ function handleToolNamesList(
  * Resolve the tool surface a subagent would receive, identified either by a
  * role name (e.g. "researcher") or a live subagent id.
  *
- * For a role name: build a {@link SkillProjectionContext} matching what the
- * {@link SubagentManager} sets up at spawn time (isSubagent, allowedTools,
+ * For a role name: build a minimal {@link Conversation} stand-in matching what
+ * the {@link SubagentManager} sets up at spawn time (isSubagent, allowedTools,
  * preactivated skill ids, no client), then run the exact same
  * {@link createResolveToolsCallback} the real subagent uses to project tools
  * for its first turn. This ensures the diagnostic reports the same tool set
@@ -516,19 +516,20 @@ function handleAgentToolList(agent: string): ToolNamesListResponse {
     );
   }
 
-  // Build the same context the SubagentManager creates at spawn time:
+  // Build the same context the SubagentManager creates at spawn time. The
+  // resolver reads only this subset of Conversation state, so a minimal
+  // stand-in cast to Conversation is enough:
   //   - isSubagent: true (gates subagent-only tools like notify_parent)
   //   - subagentAllowedTools: the role's allowlist (wire gate mode by default)
   //   - preactivatedSkillIds: role skill ids merged with defaults
   //   - hasNoClient: true (subagents have no direct client)
   //   - no channel capabilities, no disk pressure, tools enabled
   const toolDefs = getAllToolDefinitions();
-  const coreToolNames = new Set(toolDefs.map((d) => d.name));
   const mergedSkillIds = mergeSkillIds(
     roleConfig.skillIds,
     DEFAULT_PREACTIVATED_SKILL_IDS,
   );
-  const ctx: SkillProjectionContext = {
+  const ctx = {
     isSubagent: true,
     subagentAllowedTools: roleConfig.allowedTools
       ? new Set(roleConfig.allowedTools)
@@ -538,10 +539,9 @@ function handleAgentToolList(agent: string): ToolNamesListResponse {
     diskPressureCleanupModeActive: false,
     skillProjectionState: new Map<string, string>(),
     skillProjectionCache: {},
-    coreToolNames,
     hasNoClient: true,
     preactivatedSkillIds: mergedSkillIds,
-  };
+  } as unknown as Conversation;
 
   // Run the real tool resolver — the same callback a subagent conversation
   // uses each turn. An empty message history simulates the first turn before
@@ -579,7 +579,7 @@ function handleAgentToolList(agent: string): ToolNamesListResponse {
  * Scope the tool inventory to a single conversation. Conversations gain
  * tools over their lifecycle (skill loads, MCP reloads), so the global
  * registry over-reports what a given conversation can actually call. We
- * read the conversation's turn snapshot (`getRegisteredToolNames()`) — a
+ * read the conversation's turn snapshot (`getRegisteredToolDefinitions()`) — a
  * pure read that does not re-run the side-effecting `resolveTools`
  * callback — and resolve each name's metadata/schema from the registry.
  */
@@ -593,25 +593,21 @@ function handleConversationToolList(
     );
   }
 
-  const names = Array.from(conversation.getRegisteredToolNames()).sort((a, b) =>
-    a.localeCompare(b),
-  );
-
-  const schemaByName = new Map<string, SchemaShape>(
-    injectActivityField(getAllTools(), ACTIVITY_SKIP_SET).map((d) => [
-      d.name,
-      d.input_schema as SchemaShape,
-    ]),
-  );
+  // The snapshot already carries each tool's definition, so read schemas off it
+  // directly (activity-injected the same way the global catalog is) rather than
+  // flattening to names and re-looking-them-up in the registry.
+  const defs = injectActivityField(
+    conversation.getRegisteredToolDefinitions(),
+    ACTIVITY_SKIP_SET,
+  ).sort((a, b) => a.name.localeCompare(b.name));
 
+  const names: string[] = [];
   const schemas: Record<string, SchemaShape> = {};
   const tools: ToolListEntry[] = [];
-  for (const name of names) {
-    const schema = schemaByName.get(name);
-    if (schema) {
-      schemas[name] = schema;
-    }
-    tools.push(toolEntryForName(name));
+  for (const def of defs) {
+    names.push(def.name);
+    schemas[def.name] = def.input_schema as SchemaShape;
+    tools.push(toolEntryForName(def.name));
   }
 
   return { names, schemas, tools };

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

@@ -65,14 +65,11 @@ export function parseSubagentMessages(
   const firstUser = messages.find((m) => m.role === "user");
   if (firstUser) {
     try {
-      const parsed = JSON.parse(firstUser.content);
-      if (Array.isArray(parsed)) {
-        const textBlock = parsed.find(
-          (b: Record<string, unknown>) => isRecord(b) && b.type === "text",
-        );
-        if (textBlock && typeof textBlock.text === "string") {
-          objective = stripForkDirectiveFraming(textBlock.text);
-        }
+      const textBlock = firstUser.content.find(
+        (b) => b.type === "text" && typeof b.text === "string",
+      );
+      if (textBlock && "text" in textBlock) {
+        objective = stripForkDirectiveFraming(textBlock.text);
       }
     } catch {
       /* ignore */
@@ -83,17 +80,15 @@ export function parseSubagentMessages(
   const events: SubagentDetailResult["events"] = [];
   const pendingTools = new Map<string, string>();
   for (const m of messages) {
-    if (m.role !== "assistant" && m.role !== "user") continue;
-    let content: unknown[];
-    try {
-      const parsed = JSON.parse(m.content);
-      content = Array.isArray(parsed) ? parsed : [];
-    } catch {
+    if (m.role !== "assistant" && m.role !== "user") {
       continue;
     }
+    const content: unknown[] = m.content;
 
     for (const block of content) {
-      if (!isRecord(block) || typeof block.type !== "string") continue;
+      if (!isRecord(block) || typeof block.type !== "string") {
+        continue;
+      }
       if (
         m.role === "assistant" &&
         block.type === "text" &&
@@ -117,7 +112,9 @@ export function parseSubagentMessages(
           toolUseId: id || undefined,
           input,
         });
-        if (id) pendingTools.set(id, name);
+        if (id) {
+          pendingTools.set(id, name);
+        }
       } else if (
         block.type === "tool_result" ||
         block.type === "web_search_tool_result" ||
@@ -132,13 +129,15 @@ export function parseSubagentMessages(
               ? (block.content as unknown[])
                   .filter((b): b is Record<string, unknown> => isRecord(b))
                   .map((b) => {
-                    if (b.type === "text" && typeof b.text === "string")
+                    if (b.type === "text" && typeof b.text === "string") {
                       return b.text;
+                    }
                     if (
                       b.type === "web_search_result" &&
                       typeof b.title === "string"
-                    )
+                    ) {
                       return `${b.title}\n${typeof b.url === "string" ? b.url : ""}`;
+                    }
                     return null;
                   })
                   .filter((s): s is string => s != null)

package/src/runtime/routes/surface-action-routes.ts

@@ -14,12 +14,10 @@ import type { TrustContext } from "../../daemon/trust-context-types.js";
 import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { processGuardianDecision } from "../guardian-action-service.js";
-import { reResolveTrustOnResetDrift } from "../guardian-vellum-migration.js";
 import {
   findLocalGuardianPrincipalId,
   resolveActorPrincipalIdForLocalGuardian,
 } from "../local-actor-identity.js";
-import { resolveLocalPrincipalTrustContext } from "../local-principal-trust.js";
 import { parseCallbackData } from "./channel-route-shared.js";
 import {
   BadRequestError,
@@ -29,6 +27,7 @@ import {
 } from "./errors.js";
 import { resolveSurfaceConversation } from "./surface-conversation-resolver.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+import { resolveVellumActorTrustContext } from "./vellum-actor-trust.js";
 
 const log = getLogger("surface-action-routes");
 
@@ -39,7 +38,10 @@ const log = getLogger("surface-action-routes");
 /**
  * Resolve trust context for the actor principal from the gateway guardian
  * binding and set it on the conversation. A vellum principal is the guardian or
- * nobody, so the mapper yields guardian or unknown.
+ * nobody, so the mapper yields guardian or unknown. Resolution (including the
+ * dev-bypass principal translation and the mutating reset-drift repair) lives
+ * in the shared {@link resolveVellumActorTrustContext} so the surface content
+ * route's read-only requester scoping cannot drift from it.
  */
 async function applyTrustContext(
   conversation: {
@@ -47,41 +49,14 @@ async function applyTrustContext(
   },
   actorPrincipalId: string | undefined,
 ): Promise<void> {
-  if (!conversation.setTrustContext) return;
-
-  const sourceChannel = "vellum";
-
-  if (!actorPrincipalId) {
-    conversation.setTrustContext({ trustClass: "guardian", sourceChannel });
+  if (!conversation.setTrustContext) {
     return;
   }
-
-  // Dev-bypass injects a synthetic principal that won't match the real
-  // guardian binding, so resolve the actual guardian principalId (gateway
-  // first, local store fallback) before mapping trust.
-  let principalId = actorPrincipalId;
-  if (isHttpAuthDisabled() && actorPrincipalId === "dev-bypass") {
-    principalId = (await findLocalGuardianPrincipalId()) ?? actorPrincipalId;
-  }
-
-  let trustCtx = await resolveLocalPrincipalTrustContext({
-    actorPrincipalId: principalId,
-    sourceChannel,
-    conversationExternalId: "local",
-  });
-  if (trustCtx.trustClass === "unknown") {
-    const healed = await reResolveTrustOnResetDrift(principalId, sourceChannel);
-    if (healed) {
-      trustCtx = healed;
-      if (healed.trustClass !== "unknown") {
-        log.info(
-          { actorPrincipalId: principalId, trustClass: trustCtx.trustClass },
-          "Trust re-resolved from local mirror after gateway reset drift (surface action)",
-        );
-      }
-    }
-  }
-  conversation.setTrustContext(trustCtx);
+  conversation.setTrustContext(
+    await resolveVellumActorTrustContext(actorPrincipalId, {
+      healResetDrift: true,
+    }),
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -115,7 +90,7 @@ async function handleSurfaceAction({
 
   // Intercept access-request approval actions (apr:<requestId>:<action>)
   // before conversation resolution — these are cross-conversation decisions
-  // that route through the canonical guardian decision primitive.
+  // that route through the guardian decision primitive.
   const aprDecision = parseCallbackData(actionId, "vellum");
   if (aprDecision) {
     // Resolve the actor's guardian principal ID. In dev mode the synthetic
@@ -223,7 +198,9 @@ async function handleSurfaceAction({
     }
     return { ok: true };
   } catch (err) {
-    if (err instanceof RouteError) throw err;
+    if (err instanceof RouteError) {
+      throw err;
+    }
     log.error(
       {
         err,
@@ -271,7 +248,9 @@ async function handleSurfaceUndo({ body, pathParams }: RouteHandlerArgs) {
     );
     return { ok: true };
   } catch (err) {
-    if (err instanceof RouteError) throw err;
+    if (err instanceof RouteError) {
+      throw err;
+    }
     log.error(
       { err, conversationId: conversationId ?? undefined, surfaceId },
       "Failed to handle surface undo",