@vellumai/assistant 0.11.1 → 0.11.2-staging.1

package/src/providers/retry.ts

@@ -4,7 +4,11 @@ import {
   resolveUsageAttribution,
   sanitizeUsageMetadataValue,
 } from "../usage/attribution.js";
-import { ProviderError, type ProviderErrorReason } from "../util/errors.js";
+import {
+  type ProviderCredentialSource,
+  ProviderError,
+  type ProviderErrorReason,
+} from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import {
   computeRetryDelay,
@@ -824,6 +828,8 @@ function addSanitizedHeader(
 export class RetryProvider implements Provider {
   public readonly name: string;
 
+  private inner: Provider;
+
   get tokenEstimationProvider(): string | undefined {
     return this.inner.tokenEstimationProvider;
   }
@@ -842,24 +848,63 @@ export class RetryProvider implements Provider {
   // the wrapper chain (callers gate on its presence). Bound straight to the
   // inner provider — count_tokens is a cheap separate endpoint and its caller
   // already falls back on error, so it needs no retry wrapping.
+  // Deliberately not re-bound when a credential refresh swaps `inner`: every
+  // outer wrapper snapshots this the same way at construction, so a re-bind
+  // here would never reach callers. count_tokens on the pre-refresh credential
+  // fails soft — its caller falls back to estimation.
   public readonly countInputTokens?: NonNullable<Provider["countInputTokens"]>;
 
   constructor(
-    private readonly inner: Provider,
-    private readonly options: { forwardUsageAttributionHeaders?: boolean } = {},
+    inner: Provider,
+    private readonly options: {
+      forwardUsageAttributionHeaders?: boolean;
+      credentialSource?: ProviderCredentialSource;
+      connectionName?: string;
+      refreshCredentialProvider?: () => Promise<Provider | null>;
+    } = {},
   ) {
+    this.inner = inner;
     this.name = inner.name;
     if (inner.countInputTokens) {
       this.countInputTokens = inner.countInputTokens.bind(inner);
     }
   }
 
+  private shouldRefreshManagedCredential(error: unknown): boolean {
+    return (
+      this.options.credentialSource === "vellum-managed" &&
+      this.options.refreshCredentialProvider !== undefined &&
+      error instanceof ProviderError &&
+      (error.statusCode === 401 || error.statusCode === 403) &&
+      (error.reason === undefined ||
+        error.reason === "unknown" ||
+        error.reason === "invalid_credentials")
+    );
+  }
+
+  private attributeCredential(error: unknown): void {
+    const { credentialSource, connectionName } = this.options;
+    if (
+      !(error instanceof ProviderError) ||
+      (!credentialSource && !connectionName)
+    ) {
+      return;
+    }
+    // Merges under whatever a closer layer already stamped, so a route
+    // resolved at dispatch keeps precedence over this adapter's own view.
+    error.attachRouteAttribution({
+      ...(credentialSource ? { credentialSource } : {}),
+      ...(connectionName ? { connectionName } : {}),
+    });
+  }
+
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
-    let lastError: unknown;
     let didRetry = false;
+    let retryAttempt = 0;
+    let credentialRefreshAttempted = false;
     let messagesForAttempt = messages;
 
     const normalizedOptions = normalizeSendMessageOptions(this.name, options, {
@@ -867,7 +912,7 @@ export class RetryProvider implements Provider {
         this.options.forwardUsageAttributionHeaders === true,
     });
 
-    for (let attempt = 0; attempt <= DEFAULT_MAX_RETRIES; attempt++) {
+    while (true) {
       try {
         const result = await this.inner.sendMessage(
           messagesForAttempt,
@@ -875,9 +920,37 @@ export class RetryProvider implements Provider {
         );
         return result;
       } catch (error) {
-        lastError = error;
+        if (
+          !credentialRefreshAttempted &&
+          this.shouldRefreshManagedCredential(error)
+        ) {
+          credentialRefreshAttempted = true;
+          try {
+            const refreshed = await this.options.refreshCredentialProvider?.();
+            if (refreshed) {
+              this.inner = refreshed;
+              log.info(
+                {
+                  provider: this.name,
+                  connectionName: this.options.connectionName,
+                },
+                "Retrying managed inference with refreshed assistant credentials",
+              );
+              continue;
+            }
+          } catch (refreshError) {
+            log.warn(
+              {
+                provider: this.name,
+                connectionName: this.options.connectionName,
+                refreshError,
+              },
+              "Failed to reload managed assistant credentials",
+            );
+          }
+        }
 
-        if (attempt < DEFAULT_MAX_RETRIES && isRetryableError(error)) {
+        if (retryAttempt < DEFAULT_MAX_RETRIES && isRetryableError(error)) {
           // Malformed tool-argument JSON is conditioned on the request, so
           // resend with the corrective note. Built from the original
           // `messages` each time — the note appears exactly once no matter
@@ -890,7 +963,8 @@ export class RetryProvider implements Provider {
             error instanceof ProviderError ? error.retryAfterMs : undefined;
           const MAX_RETRY_DELAY_MS = 60_000; // Cap server-suggested delays at 60s
           const delay = Math.min(
-            retryAfter ?? computeRetryDelay(attempt, DEFAULT_BASE_DELAY_MS),
+            retryAfter ??
+              computeRetryDelay(retryAttempt, DEFAULT_BASE_DELAY_MS),
             MAX_RETRY_DELAY_MS,
           );
           const errorType =
@@ -909,7 +983,7 @@ export class RetryProvider implements Provider {
                       : "network_error";
           log.warn(
             {
-              attempt: attempt + 1,
+              attempt: retryAttempt + 1,
               maxRetries: DEFAULT_MAX_RETRIES,
               delay,
               retryAfterHeader: retryAfter !== undefined,
@@ -921,6 +995,7 @@ export class RetryProvider implements Provider {
             "Retrying after transient error",
           );
           didRetry = true;
+          retryAttempt++;
           await sleep(delay);
           continue;
         }
@@ -936,16 +1011,9 @@ export class RetryProvider implements Provider {
             true;
         }
 
+        this.attributeCredential(error);
         throw error;
       }
     }
-
-    // Unreachable in practice — the loop body always either returns or throws —
-    // but mark the last error in case execution somehow falls through.
-    if (lastError instanceof Error && isRetryableError(lastError)) {
-      (lastError as Error & { retriesExhausted?: boolean }).retriesExhausted =
-        true;
-    }
-    throw lastError;
   }
 }

package/src/providers/types.ts

@@ -2,7 +2,11 @@ import type { ToolDefinition } from "../tools/tool-types.js";
 export type { ToolDefinition };
 
 import type { LLMCallSite } from "../config/schemas/llm.js";
-import { ProviderError, type ProviderErrorReason } from "../util/errors.js";
+import {
+  ProviderError,
+  type ProviderErrorReason,
+  type ProviderRouteAttribution,
+} from "../util/errors.js";
 
 export interface TextContent {
   type: "text";
@@ -177,6 +181,7 @@ export interface Message {
 
 export type ModelIntent =
   | "balanced"
+  | "cost-optimized"
   | "latency-optimized"
   | "quality-optimized"
   | "vision-optimized";
@@ -359,6 +364,8 @@ export interface SendMessageOptions {
 
 export interface Provider {
   name: string;
+  /** Connection route whose credentials this provider instance uses. */
+  routeAttribution?: ProviderRouteAttribution;
   /**
    * Provider key used by the local token estimator to select model-family
    * specific rules (e.g. Anthropic's `width * height / 750` image sizing).

package/src/runtime/__tests__/agent-wake.test.ts

@@ -1624,6 +1624,187 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.persistedTailCalls.length).toBeGreaterThan(0);
   });
 
+  test("reports run_error when the loop swallows a provider rejection into a no-output stop", async () => {
+    // The loop's catch does not rethrow provider rejections: it emits
+    // `error` + `agent_loop_exit(reason: "error")` and returns the history
+    // unchanged. Without the exit-reason gate this read as a successful
+    // silent no-op, so state-advancing callers (the memory retrospective
+    // watermark) permanently consumed their trigger on a pass that never
+    // ran.
+    const conversation = makeWakeConversation({
+      conversationId: "conv-swallowed-rejection",
+      runImpl: async (input, onEvent) => {
+        await onEvent({
+          type: "error",
+          error: new Error("provider 400: image input not supported"),
+        });
+        await onEvent({ type: "agent_loop_exit", reason: "error" });
+        return runResult([...input]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      { conversationId: "conv-swallowed-rejection", hint: "boom", source: "t" },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({
+      invoked: false,
+      producedToolCalls: false,
+      reason: "run_error",
+    });
+    // Nothing pushed, persisted, or emitted: the failed run left no trace.
+    expect(conversation.pushedMessages).toEqual([]);
+    expect(conversation.persistedTailCalls).toEqual([]);
+    expect(conversation.emittedEvents).toHaveLength(0);
+  });
+
+  test("reports run_error when a no-output run was aborted", async () => {
+    const conversation = makeWakeConversation({
+      conversationId: "conv-aborted-no-output",
+      runImpl: async (input, onEvent) => {
+        await onEvent({ type: "agent_loop_exit", reason: "aborted_pre_call" });
+        return runResult([...input]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      { conversationId: "conv-aborted-no-output", hint: "boom", source: "t" },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({
+      invoked: false,
+      producedToolCalls: false,
+      reason: "run_error",
+    });
+  });
+
+  test("reports run_error when a no-output run exhausted its output budget (max_tokens_reached)", async () => {
+    // Hidden thinking can consume the whole output budget before any
+    // visible text or executable tool call lands. That is "no usable
+    // output", not a clean silent no-op: state-advancing callers must see
+    // a retryable failure. A truncated response that produced SOME output
+    // takes the normal produced-output path and never reaches this check.
+    const conversation = makeWakeConversation({
+      conversationId: "conv-max-tokens-no-output",
+      runImpl: async (input, onEvent) => {
+        await onEvent({
+          type: "agent_loop_exit",
+          reason: "max_tokens_reached",
+        });
+        return runResult([...input]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: "conv-max-tokens-no-output",
+        hint: "boom",
+        source: "t",
+      },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({
+      invoked: false,
+      producedToolCalls: false,
+      reason: "run_error",
+    });
+  });
+
+  test("keeps invoked true on a non-clean exit when a checkpoint already went live", async () => {
+    // Mirror of the throw path's went-live guard: once a checkpoint fired,
+    // side effects (e.g. `remember` calls) have already landed, so even a
+    // rebased history whose tail slice reads empty must not report the run
+    // as skipped: callers would re-run a pass whose side effects fired.
+    const assistantToolMsg: Message = {
+      role: "assistant",
+      content: [{ type: "tool_use", id: "tu-1", name: "remember", input: {} }],
+    };
+    const toolResultMsg: Message = {
+      role: "user",
+      content: [{ type: "tool_result", tool_use_id: "tu-1", content: "saved" }],
+    };
+    const conversation = makeWakeConversation({
+      conversationId: "conv-live-then-error",
+      runImpl: async (input, onEvent, runOptions) => {
+        const history = [...input, assistantToolMsg, toolResultMsg];
+        await runOptions?.onCheckpoint?.({
+          turnIndex: 0,
+          toolCount: 1,
+          hasToolUse: true,
+          history,
+        });
+        await onEvent({ type: "agent_loop_exit", reason: "error" });
+        // Return a history rebased below the wake's tail boundary, as the
+        // loop's deep-repair / recovery-hook paths can produce.
+        return runResult([...input]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      { conversationId: "conv-live-then-error", hint: "boom", source: "t" },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    // The checkpoint's flush pushed + persisted the partial tail.
+    expect(conversation.pushedMessages.length).toBeGreaterThan(0);
+    expect(conversation.persistedTailCalls.length).toBeGreaterThan(0);
+  });
+
+  test("keeps the silent no-op on a clean no_tool_calls exit with no output", async () => {
+    // A clean model-driven stop that produced nothing stays `invoked: true`:
+    // the pass really ran, the model just had nothing to say.
+    const conversation = makeWakeConversation({
+      conversationId: "conv-clean-empty",
+      runImpl: async (input, onEvent) => {
+        await onEvent({ type: "agent_loop_exit", reason: "no_tool_calls" });
+        return runResult([...input]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      { conversationId: "conv-clean-empty", hint: "hi", source: "t" },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+  });
+
+  test("reports no_output on a clean empty reply when the caller requires usable output", async () => {
+    // Same clean no_tool_calls empty run as above, but the caller consumes
+    // its trigger on success (memory retrospective): the empty reply must
+    // read as a retryable failure, not a silent success.
+    const conversation = makeWakeConversation({
+      conversationId: "conv-clean-empty-required",
+      runImpl: async (input, onEvent) => {
+        await onEvent({ type: "agent_loop_exit", reason: "no_tool_calls" });
+        return runResult([...input]);
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: "conv-clean-empty-required",
+        hint: "hi",
+        source: "t",
+        requireUsableOutput: true,
+      },
+      { resolveTarget: async () => conversation },
+    );
+
+    expect(result).toEqual({
+      invoked: false,
+      producedToolCalls: false,
+      reason: "no_output",
+    });
+    // Nothing persisted or emitted by the failed pass.
+    expect(conversation.persistedTailCalls).toEqual([]);
+    expect(conversation.emittedEvents).toHaveLength(0);
+  });
+
   test("elevates the turn's trust context before the agent loop runs", async () => {
     // Background system jobs (e.g. memory consolidation) need guardian trust to
     // clear the side-effect approval gate. The wake must set

package/src/runtime/agent-wake.ts

@@ -32,8 +32,16 @@
  *       text stay on the ephemeral trio above.
  *   - Invokes the agent loop with all conversation tools available unless
  *     the caller provides an explicit `allowedTools` scope.
- *   - No tool calls AND no assistant text → silent no-op (nothing persisted,
- *     nothing emitted). Returns `{ invoked: true, producedToolCalls: false }`.
+ *   - No tool calls AND no assistant text on a clean model-driven stop →
+ *     silent no-op (nothing persisted, nothing emitted). Returns
+ *     `{ invoked: true, producedToolCalls: false }`. When the no-output run
+ *     instead ended on a non-clean terminal exit (the loop swallowed a
+ *     provider rejection, unhandled throw, or cancellation into a graceful
+ *     no-output stop), returns `{ invoked: false, reason: "run_error" }` so
+ *     state-advancing callers retry instead of recording a phantom pass.
+ *     Callers that pass `requireUsableOutput: true` additionally get
+ *     `{ invoked: false, reason: "no_output" }` for the clean-stop empty
+ *     reply instead of the silent no-op.
  *   - Tool calls produced → normal tool execution runs (the conversation's
  *     `AgentLoop` has its tool executor already wired). Returns
  *     `{ invoked: true, producedToolCalls: true }`.
@@ -64,6 +72,7 @@
 
 import type {
   AgentEvent,
+  AgentLoopExitReason,
   CheckpointDecision,
   CheckpointInfo,
 } from "../agent/loop.js";
@@ -175,6 +184,28 @@ function buildBackgroundEventText(
 const OVER_WINDOW_REJECTION_LOG_MESSAGE =
   "agent-wake: provider rejected the input as over-window with auto-compaction suppressed; failing the wake";
 
+/**
+ * Terminal `agent_loop_exit` reasons under which a no-output run is a
+ * legitimate silent no-op: the loop reached a real model reply (or a
+ * model-driven stop) and the model simply produced nothing worth emitting.
+ * Every other reason on a no-output run means the pass never committed
+ * usable output, so the wake must report `invoked: false` instead of a
+ * phantom success: `error` (the loop's catch swallowed a provider rejection
+ * or an unhandled throw into a graceful no-output stop), the `aborted_*`
+ * family (cancellation before any output), the overflow terminals, and
+ * `max_tokens_reached` (the output budget was exhausted, e.g. by hidden
+ * thinking, before any visible text or executable tool call landed; a
+ * truncated response that DID produce output takes the normal path and
+ * never reaches this check). Membership is an allowlist deliberately: a
+ * future exit reason defaults to the failure side, which state-advancing
+ * callers recover from by retrying, rather than the data-loss side.
+ */
+const CLEAN_NO_OUTPUT_EXIT_REASONS: ReadonlySet<AgentLoopExitReason> = new Set([
+  "no_tool_calls",
+  "yield_to_user",
+  "checkpoint_handoff",
+]);
+
 export interface WakeOptions {
   conversationId: string;
   hint: string;
@@ -263,6 +294,23 @@ export interface WakeOptions {
    * retrospectives whose conversation title already says "(Retrospective)").
    */
   suppressWakeSurface?: boolean;
+  /**
+   * Treat a run that commits NO usable output (no executable tool call, no
+   * visible assistant text) as a failure even when the loop's terminal exit
+   * was a clean model-driven stop, e.g. an HTTP-200 reply with an empty
+   * content array or thinking-only output. Default false: generic
+   * opportunity wakes (meet chat, scheduled nudges) legitimately let the
+   * model decide to stay silent, and their silent no-op stays
+   * `invoked: true`.
+   *
+   * Set by state-advancing callers whose trigger is consumed on success and
+   * whose contract requires committed output: the fork-based memory
+   * retrospective advances its processed-message watermark and GCs the
+   * prior retrospective on `invoked: true`, so for it an empty reply is a
+   * failed pass to retry, never a success (LUM-3013). Runs whose output
+   * already went live (checkpoint fired / tail persisted) are unaffected.
+   */
+  requireUsableOutput?: boolean;
   /**
    * Optional exact tool allowlist for this wake. Used by internal maintenance
    * jobs that need the assistant's judgment but must not execute arbitrary
@@ -383,16 +431,27 @@ export type WakeSkipReason =
    */
   | "context_overflow"
   /**
-   * The agent loop threw before producing ANY output — no checkpoint fired
-   * and no tail message was emitted or persisted (typically a provider
-   * failure on the run's first LLM call). The wake did no work, so callers
-   * that treat `invoked: true` as "the pass ran" (e.g. the memory
+   * The agent loop terminated abnormally before producing ANY output: either
+   * it threw before a checkpoint fired or a tail message was persisted, or it
+   * swallowed a terminal failure (provider rejection, unhandled throw,
+   * cancellation) into a graceful no-output stop whose `agent_loop_exit`
+   * reason is not a clean model-driven one (typically a provider failure on
+   * the run's first LLM call, e.g. rejected input). The wake did no work, so
+   * callers that treat `invoked: true` as "the pass ran" (e.g. the memory
    * retrospective, which advances its processed-message watermark and
    * finalizes on success) must see a retryable failure rather than a
-   * silent no-op. A throw AFTER output went live keeps `invoked: true` —
+   * silent no-op. A throw AFTER output went live keeps `invoked: true`:
    * side effects have already landed and the run must not read as skipped.
    */
-  | "run_error";
+  | "run_error"
+  /**
+   * The run ended cleanly but committed no usable output (no executable tool
+   * call, no visible assistant text: e.g. an HTTP-200 reply with an empty
+   * content array, or thinking-only output) and the caller passed
+   * `requireUsableOutput: true`. Only possible on such wakes; without the
+   * flag the same run is a silent no-op with `invoked: true`.
+   */
+  | "no_output";
 
 export interface WakeResult {
   invoked: boolean;
@@ -942,6 +1001,14 @@ export async function wakeAgentForOpportunity(
     // job. Capture the signal here so the wake can fail deterministically
     // instead (`reason: "context_overflow"`).
     let suppressedContextOverflow = false;
+    // Terminal exit reason captured from the loop's `agent_loop_exit` event.
+    // `agentLoop.run()`'s returned `exitReason` only distinguishes checkpoint
+    // handoffs, so this event is the wake's only view of HOW the loop ended.
+    // Read by the no-output branch below to tell a genuine silent no-op
+    // (model produced nothing) from a swallowed terminal failure (the loop's
+    // catch turns provider rejections and unhandled throws into a graceful
+    // no-output stop instead of rethrowing).
+    let terminalExitReason: AgentLoopExitReason | null = null;
     const persistLog = (record: PendingLog): void => {
       try {
         recordRequestLog(
@@ -1072,6 +1139,7 @@ export async function wakeAgentForOpportunity(
       // reason is stashed and applied in `goLive` after pendingLogs are
       // persisted, preserving the same ordering guarantee.
       if (event.type === "agent_loop_exit") {
+        terminalExitReason = event.reason;
         if (mode === "buffering") {
           pendingExitReason = event.reason;
         } else {
@@ -1264,6 +1332,13 @@ export async function wakeAgentForOpportunity(
     // finally's error log names the reported outcome so the line matches
     // what the caller actually saw.
     let reportedRunErrorAsFailure = false;
+    // Set when a no-output run was reported as `invoked: false`, either
+    // because it ended on a non-clean terminal exit reason ("run_error") or
+    // because the caller requires usable output ("no_output"). The failure
+    // site logs its own dedicated warn line; the finally skips its generic
+    // "silent no-op" line for these paths so a failed wake never reads as a
+    // successful empty one.
+    let reportedSwallowedStopAsFailure = false;
     // Shared failure path for an over-window condition on a
     // compaction-suppressed wake (reached from the pre-flight estimate, from
     // the run's catch when the rejection escaped as a throw, or post-run when
@@ -1464,6 +1539,54 @@ export async function wakeAgentForOpportunity(
       const producedOutput = producedToolCalls || hasVisibleText;
 
       if (!producedOutput || tailMessages.length === 0) {
+        // No output. Whether that reads as success depends on WHY the loop
+        // stopped: the loop's catch swallows provider rejections, unhandled
+        // throws, and cancellation into a graceful no-output stop instead of
+        // rethrowing, and reporting that as a successful silent no-op lets
+        // state-advancing callers (the memory retrospective watermark, the
+        // scheduler's success feed) permanently consume their trigger on a
+        // pass that never ran. Gate on the terminal exit reason: a clean
+        // model-driven stop is a real silent no-op; anything else fails the
+        // wake so the caller retries.
+        // The went-live guard mirrors the throw path above: once a
+        // checkpoint fired or a tail message was persisted, side effects
+        // have already landed and the run must keep `invoked: true` even if
+        // the returned history's tail slice reads empty (the loop's
+        // deep-repair and recovery-hook paths rebase `history`, which can
+        // misalign the wake's external tail indexes).
+        const nothingWentLive =
+          mode === "buffering" && persistedTailIndex === 0;
+        if (
+          nothingWentLive &&
+          terminalExitReason !== null &&
+          !CLEAN_NO_OUTPUT_EXIT_REASONS.has(terminalExitReason)
+        ) {
+          reportedSwallowedStopAsFailure = true;
+          log.warn(
+            { conversationId, source, exitReason: terminalExitReason },
+            "agent-wake: agent loop ended with no output on a non-clean exit; reported as run_error",
+          );
+          return {
+            invoked: false,
+            producedToolCalls: false,
+            reason: "run_error" as const,
+          };
+        }
+        // Clean stop with no usable output. For callers that consume a
+        // trigger on success (requireUsableOutput), an empty reply is a
+        // failed pass to retry, not a success to record.
+        if (nothingWentLive && opts.requireUsableOutput === true) {
+          reportedSwallowedStopAsFailure = true;
+          log.warn(
+            { conversationId, source, exitReason: terminalExitReason },
+            "agent-wake: agent loop committed no usable output and the caller requires it; reported as no_output",
+          );
+          return {
+            invoked: false,
+            producedToolCalls: false,
+            reason: "no_output" as const,
+          };
+        }
         // Silent no-op: drop buffered events, push nothing, persist
         // nothing, emit nothing. (No checkpoint fired during the run
         // since checkpoints only fire after tool turns and there were
@@ -1540,7 +1663,7 @@ export async function wakeAgentForOpportunity(
 
       const durationMs = nowFn() - startedAt;
       const suppressWakeSurface = opts.suppressWakeSurface === true;
-      if (failedContextOverflow) {
+      if (failedContextOverflow || reportedSwallowedStopAsFailure) {
         // Already logged its own dedicated warn line at the failure site;
         // a generic "silent no-op" line here would misclassify a failed
         // wake as a successful empty one.

package/src/runtime/channel-approval-types.ts

@@ -102,6 +102,31 @@ export function isParkAction(action: string | undefined): boolean {
   return action !== undefined && PARK_ACTION_SET.has(action);
 }
 
+/** Outcome word per terminal guardian-request status on a resolved card. */
+const DECISION_STATUS_WORDS: Record<string, string> = {
+  approved: "Approved",
+  denied: "Denied",
+  expired: "Expired",
+  cancelled: "Cancelled",
+};
+
+/**
+ * The outcome word shown on a resolved guardian-request card, shared by every
+ * surface (in-app, Slack, Telegram); surfaces add only their own glyph
+ * vocabulary around it. A `denied` status reached by a park action reads as
+ * the neutral {@link PARK_STATUS_LABEL} rather than "Denied": a parked
+ * contact was neither trusted nor kept out.
+ */
+export function resolveDecisionStatusWord(
+  status: string,
+  decidedAction?: string,
+): string {
+  if (status === "denied" && isParkAction(decidedAction)) {
+    return PARK_STATUS_LABEL;
+  }
+  return DECISION_STATUS_WORDS[status] ?? "Resolved";
+}
+
 /**
  * Map `GuardianDecisionAction[]` to `ApprovalActionOption[]` so channel
  * prompt payloads can be derived from the unified decision action set.

package/src/runtime/routes/__tests__/connection-routes-vs-cli-parity.test.ts

@@ -99,8 +99,8 @@ describe("CLI vs HTTP route parity", () => {
 
   test("platform connection: CLI createConnection and HTTP POST produce identical DB rows", async () => {
     const payload = {
-      name: "parity-openai-managed",
-      provider: "openai" as const,
+      name: "parity-vellum-managed",
+      provider: "vellum" as const,
       auth: { type: "platform" as const },
     };
 

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -1681,6 +1681,17 @@ describe("config invariant flag enrichment", () => {
     expect(profiles.custom!).not.toHaveProperty("invariant");
   });
 
+  test("every managed default is invariant on the wire, Speed included", async () => {
+    // The clients drive their read-only lock off this flag, so a default that
+    // resolves from the catalog with no workspace stub must still carry it.
+    const body = await configGetRoute.handler({});
+    const profiles = wireProfiles(body);
+
+    for (const name of ["balanced", "quality-optimized", "latency-optimized"]) {
+      expect(profiles[name]!.invariant).toBe(true);
+    }
+  });
+
   test("PATCH /v1/config stamps the flag on the response but never persists it", async () => {
     const body = await configPatchRoute.handler({
       body: { memory: { enabled: true } },